220 lines
7.6 KiB
Lua
220 lines
7.6 KiB
Lua
---@diagnostic disable: deprecated
|
|
local it = require "util.iterators";
|
|
local json = require "util.json";
|
|
local array = require "util.array";
|
|
local iterators = require "util.iterators";
|
|
local jid = require "util.jid";
|
|
|
|
local async_handler_wrapper = module:require "util".async_handler_wrapper;
|
|
local get_room_from_jid = module:require "util".get_room_from_jid;
|
|
local muc_domain_prefix = module:get_option_string("muc_mapper_domain_prefix", "conference");
|
|
local domain_name = "meet.jitsi"
|
|
|
|
function debug_table_recursive(aTable, depth)
|
|
if (depth > 5) then
|
|
return ""
|
|
end
|
|
local result = {}
|
|
for key, value in pairs(aTable) do
|
|
--log("debug", key);
|
|
if (type(value) == "table")
|
|
then
|
|
table.insert(result, string.format("\"%s\":%s", tostring(key), debug_table_recursive(value, depth + 1)))
|
|
elseif (type(value) == "function")
|
|
then
|
|
--table.insert(result, string.format("\"%s\":%s", tostring(key), debug_table_recursive(it.join(value))))
|
|
else
|
|
table.insert(result, string.format("\"%s\":\"%s\"", tostring(key), tostring(value)))
|
|
--log("debug", key);
|
|
end
|
|
end
|
|
return "{" .. table.concat(result, ",") .. "}"
|
|
end
|
|
|
|
function get_participants_for_room(room_name)
|
|
|
|
local room_address = jid.join(room_name, muc_domain_prefix .. "." .. domain_name);
|
|
local room = get_room_from_jid(room_address);
|
|
local occupants_json = array();
|
|
if room then
|
|
local occupants = room._occupants;
|
|
if occupants then
|
|
participant_count = iterators.count(room:each_occupant());
|
|
for _, occupant in room:each_occupant() do
|
|
-- filter focus as we keep it as hidden participant
|
|
if string.sub(occupant.nick, -string.len("/focus")) ~= "/focus" then
|
|
for _, pr in occupant:each_session() do
|
|
local nick = pr:get_child_text("nick", "http://jabber.org/protocol/nick") or "";
|
|
local email = pr:get_child_text("email") or "";
|
|
local avatarURL = pr:get_child_text("avatarURL") or "" -- does not work :(
|
|
occupants_json:push({
|
|
jid = tostring(occupant.nick),
|
|
email = tostring(email),
|
|
display_name = tostring(nick),
|
|
avatarURL = tostring(avatarURL)
|
|
});
|
|
end
|
|
end
|
|
end
|
|
end
|
|
log("debug",
|
|
"there are %s occupants in room", tostring(participant_count));
|
|
return occupants_json
|
|
else
|
|
log("debug", "no such room exists");
|
|
end
|
|
return occupants_json
|
|
end
|
|
|
|
function get_all_rooms_with_participants()
|
|
|
|
local sessions = prosody.full_sessions;
|
|
|
|
local someTable = (it.join(it.keys(sessions)));
|
|
local actual_rooms = someTable[1][2]
|
|
|
|
local roomNames = {}
|
|
for _, v in pairs(actual_rooms) do
|
|
table.insert(roomNames, v["jitsi_web_query_room"])
|
|
end
|
|
|
|
local rooms_with_participants = {}
|
|
for _, room_name in pairs(roomNames) do
|
|
rooms_with_participants[room_name] = get_participants_for_room(room_name)
|
|
end
|
|
return json.encode(rooms_with_participants)
|
|
end
|
|
|
|
--- Handles request for retrieving the room participants details
|
|
-- @param event the http event, holds the request query
|
|
-- @return GET response, containing a json with participants details
|
|
function handle_get_sessions(event)
|
|
handle_room_event()
|
|
return { status_code = 200; body = get_all_rooms_with_participants() };
|
|
end
|
|
|
|
function module.load()
|
|
-- Ensure that mod_http is loaded:
|
|
--
|
|
module:depends("http");
|
|
|
|
-- Now publish our HTTP 'app':
|
|
module:log("info", "Hello! You can reach me at: %s", module:http_url());
|
|
module:provides("http", {
|
|
route = {
|
|
["GET"] = function(event) return async_handler_wrapper(event, handle_get_sessions) end;
|
|
|
|
};
|
|
});
|
|
end
|
|
|
|
-------- event stuff
|
|
--
|
|
--
|
|
--
|
|
--
|
|
--
|
|
--
|
|
--
|
|
--
|
|
--
|
|
|
|
local http = require "net.http";
|
|
local is_healthcheck_room = module:require "util".is_healthcheck_room;
|
|
--- Start non-blocking HTTP call
|
|
-- @param url URL to call
|
|
-- @param options options table as expected by net.http where we provide optional headers, body or method.
|
|
local function async_http_request(url, options)
|
|
local completed = false;
|
|
local timed_out = false;
|
|
|
|
local function cb_(response_body, response_code)
|
|
if not timed_out then -- request completed before timeout
|
|
completed = true;
|
|
|
|
module:log("debug", "%s %s returned code %s", options.method, url, response_code);
|
|
end
|
|
end
|
|
|
|
http.request(url, options, cb_);
|
|
end
|
|
|
|
--- Checks if event is triggered by healthchecks or focus user.
|
|
function is_system_event(event)
|
|
if is_healthcheck_room(event.room.jid) then
|
|
return true;
|
|
end
|
|
|
|
if event.occupant and jid.node(event.occupant.jid) == "focus" then
|
|
return true;
|
|
end
|
|
|
|
return false;
|
|
end
|
|
|
|
function handle_room_event(event)
|
|
module:log('info', "hallo irgendwas ist passiert");
|
|
if is_system_event(event) then
|
|
return;
|
|
end
|
|
|
|
async_http_request("https://www.toptal.com/developers/postbin/1673793686086-1283829133026",
|
|
{
|
|
method = "POST",
|
|
body = get_all_rooms_with_participants()
|
|
})
|
|
|
|
end
|
|
|
|
--Helper function to wait till a component is loaded before running the given callback
|
|
function run_when_component_loaded(component_host_name, callback)
|
|
local function trigger_callback()
|
|
module:log('info', 'Component loaded %s', component_host_name);
|
|
callback(module:context(component_host_name), component_host_name);
|
|
end
|
|
|
|
if prosody.hosts[component_host_name] == nil then
|
|
module:log('debug', 'Host %s not yet loaded. Will trigger when it is loaded.', component_host_name);
|
|
prosody.events.add_handler('host-activated', function(host)
|
|
if host == component_host_name then
|
|
trigger_callback();
|
|
end
|
|
end);
|
|
else
|
|
trigger_callback();
|
|
end
|
|
end
|
|
|
|
-- Helper function to wait till a component's muc module is loaded before running the given callback
|
|
function run_when_muc_module_loaded(component_host_module, component_host_name, callback)
|
|
local function trigger_callback()
|
|
module:log('info', 'MUC module loaded for %s', component_host_name);
|
|
callback(prosody.hosts[component_host_name].modules.muc, component_host_module);
|
|
end
|
|
|
|
if prosody.hosts[component_host_name].modules.muc == nil then
|
|
module:log('debug', 'MUC module for %s not yet loaded. Will trigger when it is loaded.', component_host_name);
|
|
prosody.hosts[component_host_name].events.add_handler('module-loaded', function(event)
|
|
if (event.module == 'muc') then
|
|
trigger_callback();
|
|
end
|
|
end);
|
|
else
|
|
trigger_callback()
|
|
end
|
|
end
|
|
|
|
local main_muc_component_host = muc_domain_prefix .. "." .. domain_name
|
|
-- Handle events on main muc module
|
|
run_when_component_loaded(main_muc_component_host, function(host_module, host_name)
|
|
run_when_muc_module_loaded(host_module, host_name, function(main_muc, main_module)
|
|
main_muc_service = main_muc; -- so it can be accessed from breakout muc event handlers
|
|
|
|
-- the following must run after speakerstats (priority -1)
|
|
main_module:hook("muc-room-created", handle_room_event, -3); -- must run after handle_main_room_created
|
|
main_module:hook("muc-occupant-joined", handle_room_event, -2);
|
|
main_module:hook("muc-occupant-left", handle_room_event, -2);
|
|
main_module:hook("muc-room-destroyed", handle_room_event, -2);
|
|
end);
|
|
end);
|