0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-12-25 06:53:58 +01:00
construct/modules/client/publicrooms.cc

223 lines
4 KiB
C++

// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.
using namespace ircd;
mapi::header
IRCD_MODULE
{
"Client 7.5 :Public Rooms"
};
resource
publicrooms_resource
{
"/_matrix/client/r0/publicRooms",
{
"(7.5) Lists the public rooms on the server. "
}
};
conf::item<size_t>
flush_hiwat
{
{ "name", "ircd.client.publicrooms.flush.hiwat" },
{ "default", 16384L },
};
static resource::response
get__publicrooms(client &,
const resource::request &);
resource::method
post_method
{
publicrooms_resource, "POST", get__publicrooms
};
resource::method
get_method
{
publicrooms_resource, "GET", get__publicrooms
};
resource::response
get__publicrooms(client &client,
const resource::request &request)
{
char since_buf[m::room::id::buf::SIZE];
const string_view &since
{
request.has("since")?
unquote(request["since"]):
url::decode(since_buf, request.query["since"])
};
if(since && !valid(m::id::ROOM, since))
throw m::BAD_REQUEST
{
"Invalid since token for this server."
};
char server_buf[256];
string_view server
{
url::decode(server_buf, request.query["server"])
};
const size_t limit
{
request.has("limit")?
request.at<size_t>("limit"):
request.query.get<size_t>("limit", -1UL)
};
const bool include_all_networks
{
request.get<bool>("include_all_networks", false)
};
const json::object &filter
{
request["filter"]
};
const json::string &search_term
{
filter["generic_search_term"]
};
if(!server && m::valid(m::id::ROOM_ALIAS, search_term))
server = m::id::room_alias(search_term).host();
if(server && !my_host(server)) try
{
m::rooms::summary::fetch
{
server,
since,
limit,
search_term
};
}
catch(const std::exception &e)
{
log::error
{
m::log, "Failed to fetch public rooms from '%s' :%s",
server,
e.what()
};
}
resource::response::chunked response
{
client, http::OK
};
json::stack out
{
response.buf, response.flusher(), size_t(flush_hiwat)
};
m::rooms::opts opts;
opts.join_rule = "public";
opts.summary = true;
opts.search_term = search_term;
opts.lower_bound = true;
opts.room_id = since;
if(m::valid(m::id::USER, search_term))
opts.user_id = search_term;
opts.room_alias =
startswith(search_term, m::id::ROOM_ALIAS)?
string_view{search_term}:
string_view{};
opts.server =
server?
server:
opts.room_alias || opts.user_id?
string_view{}:
my_host();
log::debug
{
m::log, "public rooms query server[%s] search[%s] filter:%s"
" user_id:%b room_alias:%b allnet:%b since:%s",
opts.server,
opts.search_term,
string_view{filter},
bool(opts.user_id),
bool(opts.room_alias),
include_all_networks,
since,
};
size_t count{0};
m::room::id::buf prev_batch_buf; //TODO: XXX
m::room::id::buf next_batch_buf;
json::stack::object top{out};
{
json::stack::array chunk
{
top, "chunk"
};
m::rooms::for_each(opts, [&]
(const m::room::id &room_id)
{
if(++count > limit)
{
next_batch_buf = room_id;
return false;
}
json::stack::object obj
{
chunk
};
m::rooms::summary::get(obj, room_id);
return true;
});
}
// To count the total we clear the since token, otherwise the count
// will be the remainder.
opts.room_id = {};
const size_t total_rooms_count_estimate
{
m::rooms::count(opts)
};
json::stack::member
{
top, "total_room_count_estimate", json::value
{
long(total_rooms_count_estimate)
}
};
if(prev_batch_buf)
json::stack::member
{
top, "prev_batch", prev_batch_buf
};
if(next_batch_buf)
json::stack::member
{
top, "next_batch", next_batch_buf
};
return std::move(response);
}