1 |
|
%%%---------------------------------------------------------------------- |
2 |
|
%%% File : mod_muc_light.erl |
3 |
|
%%% Author : Piotr Nosek <piotr.nosek@erlang-solutions.com> |
4 |
|
%%% Purpose : MUC light support |
5 |
|
%%% Created : 8 Sep 2014 by Piotr Nosek <piotr.nosek@erlang-solutions.com> |
6 |
|
%%% |
7 |
|
%%% Looking for documentation excerpt that was present here for 5 years? |
8 |
|
%%% Now everything is moved to doc/modules/mod_muc_light.md |
9 |
|
%%% |
10 |
|
%%%---------------------------------------------------------------------- |
11 |
|
|
12 |
|
-module(mod_muc_light). |
13 |
|
-author('piotr.nosek@erlang-solutions.com'). |
14 |
|
|
15 |
|
-include("mongoose.hrl"). |
16 |
|
-include("jlib.hrl"). |
17 |
|
-include("mod_muc_light.hrl"). |
18 |
|
-include("mod_roster.hrl"). |
19 |
|
-include("mongoose_rsm.hrl"). |
20 |
|
-include("mongoose_config_spec.hrl"). |
21 |
|
|
22 |
|
-behaviour(gen_mod). |
23 |
|
-behaviour(mongoose_packet_handler). |
24 |
|
-behaviour(mongoose_module_metrics). |
25 |
|
|
26 |
|
%% API |
27 |
|
-export([default_host/0]). |
28 |
|
-export([server_host_to_muc_host/2]). |
29 |
|
-export([config_schema/1]). |
30 |
|
|
31 |
|
%% For Administration API |
32 |
|
-export([try_to_create_room/3, |
33 |
|
change_room_config/5, |
34 |
|
delete_room/1]). |
35 |
|
|
36 |
|
%% gen_mod callbacks |
37 |
|
-export([start/2, stop/1, config_spec/0, supported_features/0, deps/2]). |
38 |
|
|
39 |
|
%% config processing callback |
40 |
|
-export([process_config_schema/1]). |
41 |
|
|
42 |
|
%% Packet handler export |
43 |
|
-export([process_packet/5]). |
44 |
|
|
45 |
|
%% Hook handlers |
46 |
|
-export([prevent_service_unavailable/4, |
47 |
|
disco_local_items/1, |
48 |
|
remove_user/3, |
49 |
|
remove_domain/3, |
50 |
|
add_rooms_to_roster/2, |
51 |
|
process_iq_get/5, |
52 |
|
process_iq_set/4, |
53 |
|
is_muc_room_owner/4, |
54 |
|
can_access_room/4, |
55 |
|
acc_room_affiliations/2, |
56 |
|
room_exists/3, |
57 |
|
can_access_identity/4]). |
58 |
|
-export([get_room_affiliations_from_acc/1]). |
59 |
|
|
60 |
|
%% For propEr |
61 |
|
-export([apply_rsm/3]). |
62 |
|
|
63 |
|
-export([config_metrics/1]). |
64 |
|
%% for mod_muc_light_codec_legacy |
65 |
|
-export([subdomain_pattern/1]). |
66 |
|
|
67 |
|
%% For tests |
68 |
|
-export([default_schema/0, |
69 |
|
force_clear_from_ct/1]). |
70 |
|
|
71 |
|
-ignore_xref([ |
72 |
|
add_rooms_to_roster/2, apply_rsm/3, can_access_identity/4, can_access_room/4, |
73 |
|
default_schema/0, disco_local_items/1, acc_room_affiliations/2, room_exists/3, |
74 |
|
force_clear_from_ct/1, is_muc_room_owner/4, prevent_service_unavailable/4, |
75 |
|
process_iq_get/5, process_iq_set/4, remove_domain/3, remove_user/3, |
76 |
|
server_host_to_muc_host/2 |
77 |
|
]). |
78 |
|
|
79 |
|
-type muc_server() :: jid:lserver(). |
80 |
|
-type host_type() :: mongooseim:host_type(). |
81 |
|
|
82 |
|
%%==================================================================== |
83 |
|
%% API |
84 |
|
%%==================================================================== |
85 |
|
|
86 |
|
-spec supported_features() -> [atom()]. |
87 |
|
supported_features() -> |
88 |
:-( |
[dynamic_domains]. |
89 |
|
|
90 |
|
-spec default_schema() -> mod_muc_light_room_config:schema(). |
91 |
|
default_schema() -> |
92 |
|
% This list needs to be sorted |
93 |
168 |
[{<<"roomname">>, <<"Untitled">>, roomname, binary}, |
94 |
|
{<<"subject">>, <<>>, subject, binary}]. |
95 |
|
|
96 |
|
-spec default_host() -> mongoose_subdomain_utils:subdomain_pattern(). |
97 |
|
default_host() -> |
98 |
164 |
mongoose_subdomain_utils:make_subdomain_pattern(<<"muclight.@HOST@">>). |
99 |
|
|
100 |
|
-spec config_schema(MUCServer :: muc_server()) -> mod_muc_light_room_config:schema(). |
101 |
|
config_schema(MUCServer) -> |
102 |
138 |
HostType = mod_muc_light_utils:muc_host_to_host_type(MUCServer), |
103 |
138 |
config_schema_for_host_type(HostType). |
104 |
|
|
105 |
|
%% Internals |
106 |
|
|
107 |
|
-spec config_schema_for_host_type(host_type()) -> mod_muc_light_room_config:schema(). |
108 |
|
config_schema_for_host_type(HostType) -> |
109 |
236 |
gen_mod:get_module_opt(HostType, ?MODULE, config_schema). |
110 |
|
|
111 |
|
force_clear_from_ct(HostType) -> |
112 |
81 |
catch mod_muc_light_cache:force_clear(HostType), |
113 |
81 |
mod_muc_light_db_backend:force_clear(HostType). |
114 |
|
|
115 |
|
%%==================================================================== |
116 |
|
%% Administration API |
117 |
|
%%==================================================================== |
118 |
|
|
119 |
|
-spec try_to_create_room(CreatorJid :: jid:jid(), RoomJID :: jid:jid(), |
120 |
|
CreationCfg :: create_req_props()) -> |
121 |
|
{ok, jid:jid(), create_req_props()} | validation_error() |
122 |
|
| {error, bad_request | exists | max_occupants_reached}. |
123 |
|
try_to_create_room(CreatorJid, RoomJID, #create{raw_config = RawConfig} = CreationCfg) -> |
124 |
103 |
RoomUS = jid:to_lus(RoomJID), |
125 |
103 |
HostType = mod_muc_light_utils:room_jid_to_host_type(RoomJID), |
126 |
98 |
CfgRes = prepare_config(HostType, RawConfig), |
127 |
98 |
AffRes = prepare_affs(HostType, CreatorJid, RoomUS, CreationCfg), |
128 |
98 |
case {CfgRes, AffRes} of |
129 |
|
{{ok, Config0}, {ok, FinalAffUsers}} -> |
130 |
97 |
Version = mongoose_bin:gen_from_timestamp(), |
131 |
97 |
case mod_muc_light_db_backend:create_room( |
132 |
|
HostType, RoomUS, lists:sort(Config0), FinalAffUsers, Version) of |
133 |
|
{ok, {FinalU, FinalS}} -> |
134 |
92 |
{ok, jid:make_noprep(FinalU, FinalS, <<>>), CreationCfg#create{ |
135 |
|
aff_users = FinalAffUsers, version = Version}}; |
136 |
|
Other -> |
137 |
5 |
Other |
138 |
|
end; |
139 |
|
{{error, _} = Error, _} -> |
140 |
:-( |
Error; |
141 |
|
{_, {error, _} = Error} -> |
142 |
1 |
Error |
143 |
|
end. |
144 |
|
|
145 |
|
-spec change_room_config(UserJid :: jid:jid(), RoomID :: jid:user(), |
146 |
|
MUCLightDomain :: jid:server(), |
147 |
|
ConfigReq :: config_req_props(), |
148 |
|
Acc :: mongoose_acc:t()) -> |
149 |
|
{ok, jid:jid(), config_req_props()} |
150 |
|
| {error, validation_error() | bad_request | not_allowed | not_exists | item_not_found}. |
151 |
|
change_room_config(UserJid, RoomID, MUCLightDomain, ConfigReq, Acc1) -> |
152 |
11 |
RoomJID = jid:make(RoomID, MUCLightDomain, <<>>), |
153 |
11 |
{Acc2, AffUsersRes} = get_room_affiliations_from_acc(Acc1, RoomJID), |
154 |
11 |
case mod_muc_light_room:process_request(UserJid, RoomJID, {set, ConfigReq}, |
155 |
|
AffUsersRes, Acc2) of |
156 |
|
{set, ConfigResp, _} -> |
157 |
4 |
{ok, RoomJID, ConfigResp}; |
158 |
|
{error, _Reason} = E -> |
159 |
7 |
E |
160 |
|
end. |
161 |
|
|
162 |
|
-spec delete_room(RoomUS :: jid:simple_bare_jid()) -> ok | {error, not_exists}. |
163 |
|
delete_room({_, RoomS} = RoomUS) -> |
164 |
5 |
HostType = mod_muc_light_utils:muc_host_to_host_type(RoomS), |
165 |
4 |
mod_muc_light_db_backend:destroy_room(HostType, RoomUS). |
166 |
|
|
167 |
|
%%==================================================================== |
168 |
|
%% gen_mod callbacks |
169 |
|
%%==================================================================== |
170 |
|
|
171 |
|
-spec start(host_type(), gen_mod:module_opts()) -> ok. |
172 |
|
start(HostType, Opts) -> |
173 |
41 |
Codec = host_type_to_codec(HostType), |
174 |
41 |
mod_muc_light_db_backend:start(HostType, Opts), |
175 |
41 |
mod_muc_light_codec_backend:start(HostType, [{backend, Codec}]), |
176 |
41 |
ejabberd_hooks:add(hooks(HostType)), |
177 |
|
%% Handler |
178 |
41 |
SubdomainPattern = subdomain_pattern(HostType), |
179 |
41 |
PacketHandler = mongoose_packet_handler:new(?MODULE), |
180 |
41 |
mongoose_domain_api:register_subdomain(HostType, SubdomainPattern, PacketHandler), |
181 |
41 |
ok. |
182 |
|
|
183 |
|
-spec stop(host_type()) -> ok. |
184 |
|
stop(HostType) -> |
185 |
41 |
SubdomainPattern = subdomain_pattern(HostType), |
186 |
41 |
mongoose_domain_api:unregister_subdomain(HostType, SubdomainPattern), |
187 |
41 |
ejabberd_hooks:delete(hooks(HostType)), |
188 |
41 |
mod_muc_light_codec_backend:stop(HostType), |
189 |
41 |
mod_muc_light_db_backend:stop(HostType), |
190 |
41 |
ok. |
191 |
|
|
192 |
|
-spec deps(mongooseim:host_type(), gen_mod:module_opts()) -> gen_mod_deps:deps(). |
193 |
|
deps(_HostType, #{cache_affs := CacheOpts}) -> |
194 |
208 |
[{mod_muc_light_cache, CacheOpts, hard}]; |
195 |
|
deps(_HostType, #{}) -> |
196 |
181 |
[]. |
197 |
|
|
198 |
|
%% Init helpers |
199 |
|
subdomain_pattern(HostType) -> |
200 |
96 |
gen_mod:get_module_opt(HostType, ?MODULE, host). |
201 |
|
|
202 |
|
server_host_to_muc_host(HostType, ServerHost) -> |
203 |
11 |
mongoose_subdomain_utils:get_fqdn(subdomain_pattern(HostType), ServerHost). |
204 |
|
|
205 |
|
host_type_to_codec(HostType) -> |
206 |
123 |
case gen_mod:get_module_opt(HostType, ?MODULE, legacy_mode) of |
207 |
|
true -> |
208 |
27 |
legacy; |
209 |
|
false -> |
210 |
96 |
modern |
211 |
|
end. |
212 |
|
|
213 |
|
%% Config callbacks |
214 |
|
-spec config_spec() -> mongoose_config_spec:config_section(). |
215 |
|
config_spec() -> |
216 |
164 |
#section{ |
217 |
|
items = #{<<"backend">> => #option{type = atom, |
218 |
|
validate = {module, mod_muc_light_db}}, |
219 |
|
<<"cache_affs">> => mod_muc_light_cache:config_spec(), |
220 |
|
<<"host">> => #option{type = string, |
221 |
|
validate = subdomain_template, |
222 |
|
process = fun mongoose_subdomain_utils:make_subdomain_pattern/1}, |
223 |
|
<<"equal_occupants">> => #option{type = boolean}, |
224 |
|
<<"legacy_mode">> => #option{type = boolean}, |
225 |
|
<<"rooms_per_user">> => #option{type = int_or_infinity, |
226 |
|
validate = positive}, |
227 |
|
<<"blocking">> => #option{type = boolean}, |
228 |
|
<<"all_can_configure">> => #option{type = boolean}, |
229 |
|
<<"all_can_invite">> => #option{type = boolean}, |
230 |
|
<<"max_occupants">> => #option{type = int_or_infinity, |
231 |
|
validate = positive}, |
232 |
|
<<"rooms_per_page">> => #option{type = int_or_infinity, |
233 |
|
validate = positive}, |
234 |
|
<<"rooms_in_rosters">> => #option{type = boolean}, |
235 |
|
<<"config_schema">> => #list{items = config_schema_spec(), |
236 |
|
process = fun ?MODULE:process_config_schema/1} |
237 |
|
}, |
238 |
|
defaults = #{<<"backend">> => mnesia, |
239 |
|
<<"host">> => default_host(), |
240 |
|
<<"equal_occupants">> => ?DEFAULT_EQUAL_OCCUPANTS, |
241 |
|
<<"legacy_mode">> => ?DEFAULT_LEGACY_MODE, |
242 |
|
<<"rooms_per_user">> => ?DEFAULT_ROOMS_PER_USER, |
243 |
|
<<"blocking">> => ?DEFAULT_BLOCKING, |
244 |
|
<<"all_can_configure">> => ?DEFAULT_ALL_CAN_CONFIGURE, |
245 |
|
<<"all_can_invite">> => ?DEFAULT_ALL_CAN_INVITE, |
246 |
|
<<"max_occupants">> => ?DEFAULT_MAX_OCCUPANTS, |
247 |
|
<<"rooms_per_page">> => ?DEFAULT_ROOMS_PER_PAGE, |
248 |
|
<<"rooms_in_rosters">> => ?DEFAULT_ROOMS_IN_ROSTERS, |
249 |
|
<<"config_schema">> => default_schema()}, |
250 |
|
format_items = map |
251 |
|
}. |
252 |
|
|
253 |
|
config_schema_spec() -> |
254 |
164 |
#section{ |
255 |
|
items = #{<<"field">> => #option{type = binary, |
256 |
|
validate = non_empty}, |
257 |
|
<<"string_value">> => #option{type = binary}, |
258 |
|
<<"integer_value">> => #option{type = integer}, |
259 |
|
<<"float_value">> => #option{type = float}, |
260 |
|
<<"internal_key">> => #option{type = atom, |
261 |
|
validate = non_empty} |
262 |
|
}, |
263 |
|
required = [<<"field">>], |
264 |
|
format_items = map |
265 |
|
}. |
266 |
|
|
267 |
|
-spec process_config_schema([map()]) -> mod_muc_light_room_config:schema(). |
268 |
|
process_config_schema(Items) -> |
269 |
:-( |
lists:ukeysort(1, lists:map(fun process_config_schema_item/1, Items)). |
270 |
|
|
271 |
|
process_config_schema_item(#{field := FieldName} = FieldSpec) -> |
272 |
:-( |
InternalKey = maps:get(internal_key, FieldSpec, binary_to_atom(FieldName)), |
273 |
:-( |
FieldTypes = schema_field_types(), |
274 |
:-( |
case [K || K <- maps:keys(FieldTypes), maps:is_key(K, FieldSpec)] of |
275 |
|
[Key] -> |
276 |
:-( |
{FieldName, maps:get(Key, FieldSpec), InternalKey, maps:get(Key, FieldTypes)}; |
277 |
|
_ -> |
278 |
:-( |
error(#{what => invalid_schema_field_specification, field_spec => FieldSpec}) |
279 |
|
end. |
280 |
|
|
281 |
|
schema_field_types() -> |
282 |
:-( |
#{string_value => binary, integer_value => integer, float_value => float}. |
283 |
|
|
284 |
|
hooks(HostType) -> |
285 |
82 |
Codec = host_type_to_codec(HostType), |
286 |
82 |
Roster = gen_mod:get_module_opt(HostType, ?MODULE, rooms_in_rosters), |
287 |
|
[{is_muc_room_owner, HostType, ?MODULE, is_muc_room_owner, 50}, |
288 |
|
{can_access_room, HostType, ?MODULE, can_access_room, 50}, |
289 |
|
{acc_room_affiliations, HostType, ?MODULE, acc_room_affiliations, 50}, |
290 |
|
{room_exists, HostType, ?MODULE, room_exists, 50}, |
291 |
|
{can_access_identity, HostType, ?MODULE, can_access_identity, 50}, |
292 |
|
%% Prevent sending service-unavailable on groupchat messages |
293 |
|
{offline_groupchat_message_hook, HostType, ?MODULE, prevent_service_unavailable, 90}, |
294 |
|
{remove_user, HostType, ?MODULE, remove_user, 50}, |
295 |
|
{remove_domain, HostType, ?MODULE, remove_domain, 50}, |
296 |
82 |
{disco_local_items, HostType, ?MODULE, disco_local_items, 50}] ++ |
297 |
|
case Codec of |
298 |
|
legacy -> |
299 |
18 |
[{privacy_iq_get, HostType, ?MODULE, process_iq_get, 1}, |
300 |
|
{privacy_iq_set, HostType, ?MODULE, process_iq_set, 1}]; |
301 |
|
_ -> |
302 |
64 |
[] |
303 |
|
end ++ |
304 |
|
case Roster of |
305 |
24 |
false -> []; |
306 |
58 |
true -> [{roster_get, HostType, ?MODULE, add_rooms_to_roster, 50}] |
307 |
|
end. |
308 |
|
|
309 |
|
%%==================================================================== |
310 |
|
%% Routing |
311 |
|
%%==================================================================== |
312 |
|
|
313 |
|
-spec process_packet(Acc :: mongoose_acc:t(), From ::jid:jid(), To ::jid:jid(), |
314 |
|
El :: exml:element(), Extra :: map()) -> mongoose_acc:t(). |
315 |
|
process_packet(Acc, From, To, El, _Extra) -> |
316 |
253 |
HostType = mod_muc_light_utils:acc_to_host_type(Acc), |
317 |
253 |
DecodedPacket = mod_muc_light_codec_backend:decode(From, To, El, Acc), |
318 |
253 |
process_decoded_packet(HostType, From, To, Acc, El, DecodedPacket). |
319 |
|
|
320 |
|
-spec process_decoded_packet( |
321 |
|
HostType :: host_type(), |
322 |
|
From :: jid:jid(), To :: jid:jid(), |
323 |
|
Acc :: mongoose_acc:t(), |
324 |
|
OrigPacket :: exml:element(), |
325 |
|
DecodedPacket :: mod_muc_light_codec_backend:decode_result()) -> |
326 |
|
mongoose_acc:t(). |
327 |
|
process_decoded_packet(HostType, From, To, Acc, El, |
328 |
|
{ok, {set, #create{} = Create}}) -> |
329 |
40 |
case not mod_muc_light_utils:room_limit_reached(From, HostType) of |
330 |
39 |
true -> create_room(Acc, From, To, Create, El); |
331 |
1 |
false -> make_err(From, To, El, Acc, {error, room_limit_reached}) |
332 |
|
end; |
333 |
|
process_decoded_packet(_HostType, From, To, Acc, _El, |
334 |
|
{ok, {get, #disco_info{} = DI}}) -> |
335 |
4 |
handle_disco_info_get(From, To, DI, Acc); |
336 |
|
process_decoded_packet(HostType, From, To, Acc, El, |
337 |
|
{ok, {get, #disco_items{} = DI}}) -> |
338 |
21 |
handle_disco_items_get(HostType, Acc, From, To, DI, El); |
339 |
|
process_decoded_packet(HostType, From, To, Acc, El, |
340 |
|
{ok, {_, #blocking{}} = Blocking}) -> |
341 |
13 |
case gen_mod:get_module_opt(HostType, ?MODULE, blocking) of |
342 |
|
true -> |
343 |
11 |
case handle_blocking(Acc, From, To, Blocking) of |
344 |
:-( |
{error, _} = Res -> make_err(From, To, El, Acc, Res); |
345 |
11 |
_ -> Acc |
346 |
|
end; |
347 |
2 |
false -> make_err(From, To, El, Acc, {error, blocking_disabled}) |
348 |
|
end; |
349 |
|
process_decoded_packet(_HostType, From, To, Acc, El, |
350 |
|
{ok, #iq{} = IQ}) -> |
351 |
:-( |
case mod_muc_iq:process_iq(To#jid.lserver, From, To, Acc, IQ) of |
352 |
|
{Acc1, error} -> |
353 |
:-( |
E = {error, {feature_not_implemented, <<"mod_muc_iq returns error">>}}, |
354 |
:-( |
make_err(From, To, El, Acc1, E); |
355 |
:-( |
_ -> Acc |
356 |
|
end; |
357 |
|
process_decoded_packet(HostType, From, To, Acc, El, |
358 |
|
{ok, RequestToRoom}) |
359 |
|
when To#jid.luser =/= <<>> -> |
360 |
171 |
case mongoose_hooks:room_exists(HostType, To) of |
361 |
170 |
true -> mod_muc_light_room:handle_request(From, To, El, RequestToRoom, Acc); |
362 |
1 |
false -> make_err(From, To, El, Acc, {error, item_not_found}) |
363 |
|
end; |
364 |
|
process_decoded_packet(_HostType, From, To, Acc, El, |
365 |
|
{error, _} = Err) -> |
366 |
1 |
make_err(From, To, El, Acc, Err); |
367 |
|
process_decoded_packet(_HostType, _From, _To, Acc, _El, ignore) -> |
368 |
3 |
Acc; |
369 |
|
process_decoded_packet(_HostType, From, To, Acc, El, InvalidReq) -> |
370 |
:-( |
?LOG_WARNING(#{what => muc_light_invalid_request, |
371 |
:-( |
acc => Acc, reason => InvalidReq}), |
372 |
:-( |
make_err(From, To, El, Acc, {error, bad_request}). |
373 |
|
|
374 |
|
make_err(From, To, El, Acc, Reason) -> |
375 |
5 |
mod_muc_light_codec_backend:encode_error(Reason, From, To, El, Acc). |
376 |
|
|
377 |
|
%%==================================================================== |
378 |
|
%% Hook handlers |
379 |
|
%%==================================================================== |
380 |
|
|
381 |
|
-spec prevent_service_unavailable(Acc :: map(), From ::jid:jid(), To ::jid:jid(), |
382 |
|
Packet :: exml:element()) -> map() | {stop, map()}. |
383 |
|
prevent_service_unavailable(Acc, _From, _To, Packet) -> |
384 |
144 |
case xml:get_tag_attr_s(<<"type">>, Packet) of |
385 |
144 |
<<"groupchat">> -> {stop, Acc}; |
386 |
:-( |
_Type -> Acc |
387 |
|
end. |
388 |
|
|
389 |
|
-spec disco_local_items(mongoose_disco:item_acc()) -> mongoose_disco:item_acc(). |
390 |
|
disco_local_items(Acc = #{host_type := HostType, |
391 |
|
to_jid := #jid{lserver = ServerHost}, |
392 |
|
node := <<>>}) -> |
393 |
2 |
XMLNS = case legacy_mode(HostType) of |
394 |
1 |
true -> ?NS_MUC; |
395 |
1 |
false -> ?NS_MUC_LIGHT |
396 |
|
end, |
397 |
2 |
MUCHost = server_host_to_muc_host(HostType, ServerHost), |
398 |
2 |
Items = [#{jid => MUCHost, node => XMLNS}], |
399 |
2 |
mongoose_disco:add_items(Items, Acc); |
400 |
|
disco_local_items(Acc) -> |
401 |
:-( |
Acc. |
402 |
|
|
403 |
|
legacy_mode(HostType) -> |
404 |
2 |
gen_mod:get_module_opt(HostType, ?MODULE, legacy_mode). |
405 |
|
|
406 |
|
-spec remove_user(Acc :: mongoose_acc:t(), User :: binary(), Server :: binary()) -> |
407 |
|
mongoose_acc:t(). |
408 |
|
remove_user(Acc, User, Server) -> |
409 |
139 |
HostType = mongoose_acc:host_type(Acc), |
410 |
139 |
UserJid = jid:make(User, Server, <<>>), |
411 |
139 |
Version = mongoose_bin:gen_from_timestamp(), |
412 |
139 |
case mod_muc_light_db_backend:remove_user(HostType, jid:to_lus(UserJid), Version) of |
413 |
|
{error, Reason} -> |
414 |
:-( |
?LOG_ERROR(#{what => muc_remove_user_failed, |
415 |
:-( |
reason => Reason, acc => Acc}), |
416 |
:-( |
Acc; |
417 |
|
AffectedRooms -> |
418 |
139 |
bcast_removed_user(Acc, UserJid, AffectedRooms, Version), |
419 |
139 |
maybe_forget_rooms(Acc, AffectedRooms, Version), |
420 |
139 |
Acc |
421 |
|
end. |
422 |
|
|
423 |
|
-spec remove_domain(mongoose_hooks:simple_acc(), |
424 |
|
mongooseim:host_type(), jid:lserver()) -> |
425 |
|
mongoose_hooks:simple_acc(). |
426 |
|
remove_domain(Acc, HostType, Domain) -> |
427 |
:-( |
MUCHost = server_host_to_muc_host(HostType, Domain), |
428 |
:-( |
mod_muc_light_db_backend:remove_domain(HostType, MUCHost, Domain), |
429 |
:-( |
Acc. |
430 |
|
|
431 |
|
-spec add_rooms_to_roster(Acc :: mongoose_acc:t(), UserJID :: jid:jid()) -> mongoose_acc:t(). |
432 |
|
add_rooms_to_roster(Acc, UserJID) -> |
433 |
16 |
Items = mongoose_acc:get(roster, items, [], Acc), |
434 |
16 |
HostType = mongoose_acc:host_type(Acc), |
435 |
16 |
RoomList = mod_muc_light_db_backend:get_user_rooms(HostType, jid:to_lus(UserJID), undefined), |
436 |
16 |
Info = get_rooms_info(HostType, lists:sort(RoomList)), |
437 |
16 |
NewItems = [make_roster_item(Item) || Item <- Info] ++ Items, |
438 |
16 |
mongoose_acc:set(roster, items, NewItems, Acc). |
439 |
|
|
440 |
|
make_roster_item({{RoomU, RoomS}, RoomName, RoomVersion}) -> |
441 |
5 |
JID = jid:make_noprep(RoomU, RoomS, <<>>), |
442 |
5 |
VerEl = #xmlel{ name = <<"version">>, |
443 |
|
children = [#xmlcdata{ content = RoomVersion }] }, |
444 |
5 |
#roster{usj = {RoomU, RoomS, jid:to_lower(JID)}, |
445 |
|
us = {RoomU, RoomS}, |
446 |
|
jid = jid:to_lower(JID), |
447 |
|
name = RoomName, |
448 |
|
subscription = to, |
449 |
|
groups = [?NS_MUC_LIGHT], |
450 |
|
xs = [VerEl] }. |
451 |
|
|
452 |
|
-spec process_iq_get(Acc :: mongoose_acc:t(), From :: jid:jid(), To :: jid:jid(), |
453 |
|
IQ :: jlib:iq(), ActiveList :: binary()) -> |
454 |
|
{stop, mongoose_acc:t()} | mongoose_acc:t(). |
455 |
|
process_iq_get(Acc, #jid{lserver = FromS} = From, To, #iq{} = IQ, _ActiveList) -> |
456 |
4 |
HostType = mod_muc_light_utils:acc_to_host_type(Acc), |
457 |
4 |
MUCHost = server_host_to_muc_host(HostType, FromS), |
458 |
4 |
case {mod_muc_light_codec_backend:decode(From, To, IQ, Acc), |
459 |
|
gen_mod:get_module_opt(HostType, ?MODULE, blocking)} of |
460 |
|
{{ok, {get, #blocking{} = Blocking}}, true} -> |
461 |
3 |
Items = mod_muc_light_db_backend:get_blocking(HostType, jid:to_lus(From), MUCHost), |
462 |
3 |
mod_muc_light_codec_backend:encode( |
463 |
|
{get, Blocking#blocking{ items = Items }}, From, To, |
464 |
3 |
fun(_, _, Packet) -> put(encode_res, Packet) end, |
465 |
|
Acc), |
466 |
3 |
#xmlel{ children = ResponseChildren } = erase(encode_res), |
467 |
3 |
Result = {result, ResponseChildren}, |
468 |
3 |
{stop, mongoose_acc:set(hook, result, Result, Acc)}; |
469 |
|
{{ok, {get, #blocking{}}}, false} -> |
470 |
1 |
Result = {error, mongoose_xmpp_errors:bad_request()}, |
471 |
1 |
{stop, mongoose_acc:set(hook, result, Result, Acc)}; |
472 |
|
_ -> |
473 |
:-( |
Result = {error, mongoose_xmpp_errors:bad_request()}, |
474 |
:-( |
mongoose_acc:set(hook, result, Result, Acc) |
475 |
|
end. |
476 |
|
|
477 |
|
%% Blocking is done using your local domain |
478 |
|
-spec process_iq_set(Acc :: mongoose_acc:t(), From :: jid:jid(), |
479 |
|
To :: jid:jid(), IQ :: jlib:iq()) -> |
480 |
|
{stop, mongoose_acc:t()} | mongoose_acc:t(). |
481 |
|
process_iq_set(Acc, #jid{ lserver = FromS } = From, To, #iq{} = IQ) -> |
482 |
5 |
HostType = mod_muc_light_utils:acc_to_host_type(Acc), |
483 |
5 |
MUCHost = server_host_to_muc_host(HostType, FromS), |
484 |
5 |
case {mod_muc_light_codec_backend:decode(From, To, IQ, Acc), |
485 |
|
gen_mod:get_module_opt(HostType, ?MODULE, blocking)} of |
486 |
|
{{ok, {set, #blocking{ items = Items }} = Blocking}, true} -> |
487 |
4 |
RouteFun = fun(_, _, Packet) -> put(encode_res, Packet) end, |
488 |
4 |
ConditionFun = fun({_, _, {WhoU, WhoS}}) -> WhoU =:= <<>> orelse WhoS =:= <<>> end, |
489 |
4 |
case lists:any(ConditionFun, Items) of |
490 |
|
true -> |
491 |
:-( |
{stop, mongoose_acc:set(hook, result, |
492 |
|
{error, mongoose_xmpp_errors:bad_request()}, Acc)}; |
493 |
|
false -> |
494 |
4 |
ok = mod_muc_light_db_backend:set_blocking(HostType, jid:to_lus(From), MUCHost, Items), |
495 |
4 |
mod_muc_light_codec_backend:encode(Blocking, From, To, RouteFun, Acc), |
496 |
4 |
#xmlel{ children = ResponseChildren } = erase(encode_res), |
497 |
4 |
{stop, mongoose_acc:set(hook, result, {result, ResponseChildren}, Acc)} |
498 |
|
end; |
499 |
|
{{ok, {set, #blocking{}}}, false} -> |
500 |
1 |
{stop, mongoose_acc:set(hook, result, |
501 |
|
{error, mongoose_xmpp_errors:bad_request()}, Acc)}; |
502 |
|
_ -> |
503 |
:-( |
mongoose_acc:set(hook, result, {error, mongoose_xmpp_errors:bad_request()}, Acc) |
504 |
|
end. |
505 |
|
|
506 |
|
-spec is_muc_room_owner(boolean(), Acc :: mongoose_acc:t(), |
507 |
|
Room :: jid:jid(), User :: jid:jid()) -> boolean(). |
508 |
|
is_muc_room_owner(true, _Acc, _Room, _User) -> |
509 |
:-( |
true; |
510 |
|
is_muc_room_owner(_, Acc, Room, User) -> |
511 |
:-( |
owner == get_affiliation(Acc, Room, User). |
512 |
|
|
513 |
|
-spec can_access_room(boolean(), Acc :: mongoose_acc:t(), |
514 |
|
Room :: jid:jid(), User :: jid:jid()) -> |
515 |
|
boolean(). |
516 |
|
can_access_room(true, _Acc, _Room, _User) -> |
517 |
:-( |
true; |
518 |
|
can_access_room(_, Acc, Room, User) -> |
519 |
:-( |
none =/= get_affiliation(Acc, Room, User). |
520 |
|
|
521 |
|
-spec acc_room_affiliations(mongoose_acc:t(), jid:jid()) -> mongoose_acc:t(). |
522 |
|
acc_room_affiliations(Acc1, Room) -> |
523 |
181 |
case mongoose_acc:get(?MODULE, affiliations, {error, not_exists}, Acc1) of |
524 |
|
{error, _} -> |
525 |
153 |
HostType = mongoose_acc:host_type(Acc1), |
526 |
153 |
case mod_muc_light_db_backend:get_aff_users(HostType, jid:to_lus(Room)) of |
527 |
|
{error, not_exists} -> |
528 |
2 |
Acc1; |
529 |
|
{ok, _Affs, _Version} = Res -> |
530 |
151 |
mongoose_acc:set(?MODULE, affiliations, Res, Acc1) |
531 |
|
end; |
532 |
|
_Affs -> |
533 |
28 |
Acc1 |
534 |
|
end. |
535 |
|
|
536 |
|
-spec room_exists(boolean(), mongooseim:host_type(), jid:jid()) -> boolean(). |
537 |
|
room_exists(_, HostType, RoomJid) -> |
538 |
143 |
mod_muc_light_db_backend:room_exists(HostType, jid:to_lus(RoomJid)). |
539 |
|
|
540 |
|
-spec get_room_affiliations_from_acc(mongoose_acc:t()) -> |
541 |
|
{ok, aff_users(), binary()} | {error, not_exists}. |
542 |
|
get_room_affiliations_from_acc(Acc) -> |
543 |
170 |
mongoose_acc:get(?MODULE, affiliations, {error, not_exists}, Acc). |
544 |
|
|
545 |
|
-spec get_room_affiliations_from_acc(mongoose_acc:t(), jid:jid()) -> |
546 |
|
{mongoose_acc:t(), {ok, aff_users(), binary()} | {error, not_exists}}. |
547 |
|
get_room_affiliations_from_acc(Acc1, RoomJid) -> |
548 |
11 |
Acc2 = mongoose_hooks:acc_room_affiliations(Acc1, RoomJid), |
549 |
11 |
{Acc2, mongoose_acc:get(?MODULE, affiliations, {error, not_exists}, Acc2)}. |
550 |
|
|
551 |
|
-spec can_access_identity(Acc :: boolean(), HostType :: mongooseim:host_type(), |
552 |
|
Room :: jid:jid(), User :: jid:jid()) -> |
553 |
|
boolean(). |
554 |
|
can_access_identity(true, _HostType, _Room, _User) -> |
555 |
:-( |
true; |
556 |
|
can_access_identity(_Acc, _HostType, _Room, _User) -> |
557 |
|
%% User JIDs are explicit in MUC Light but this hook is about appending |
558 |
|
%% 0045 MUC element with user identity and we don't want it |
559 |
:-( |
false. |
560 |
|
|
561 |
|
%%==================================================================== |
562 |
|
%% Internal functions |
563 |
|
%%==================================================================== |
564 |
|
|
565 |
|
prepare_config(HostType, RawConfig) -> |
566 |
98 |
Schema = config_schema_for_host_type(HostType), |
567 |
98 |
mod_muc_light_room_config:from_binary_kv(RawConfig, Schema). |
568 |
|
|
569 |
|
prepare_affs(HostType, CreatorJid, RoomUS, #create{aff_users = AffUsers}) -> |
570 |
98 |
CreatorUS = jid:to_lus(CreatorJid), |
571 |
98 |
InitialAffUsers = mod_muc_light_utils:filter_out_prevented(HostType, |
572 |
|
CreatorUS, RoomUS, AffUsers), |
573 |
98 |
Res = process_create_aff_users_if_valid(HostType, CreatorUS, InitialAffUsers), |
574 |
98 |
MaxOccupants = max_occupants(HostType), |
575 |
98 |
case Res of |
576 |
|
{ok, FinalAffUsers} when length(FinalAffUsers) > MaxOccupants -> |
577 |
1 |
{error, max_occupants_reached}; |
578 |
|
_ -> |
579 |
97 |
Res |
580 |
|
end. |
581 |
|
|
582 |
|
max_occupants(HostType) -> |
583 |
98 |
gen_mod:get_module_opt(HostType, ?MODULE, max_occupants). |
584 |
|
|
585 |
|
get_affiliation(Acc, Room, User) -> |
586 |
:-( |
case get_room_affiliations_from_acc(Acc, Room) of |
587 |
|
{_, {ok, AffUsers, _}} -> |
588 |
:-( |
case lists:keyfind(jid:to_lus(User), 1, AffUsers) of |
589 |
:-( |
{_, Aff} -> Aff; |
590 |
:-( |
_ -> none |
591 |
|
end; |
592 |
|
_ -> |
593 |
:-( |
none |
594 |
|
end. |
595 |
|
|
596 |
|
-spec create_room(mongoose_acc:t(), |
597 |
|
jid:jid(), |
598 |
|
jid:jid(), |
599 |
|
create_req_props(), |
600 |
|
exml:element()) -> |
601 |
|
mongoose_acc:t(). |
602 |
|
create_room(Acc, From, To, Create0, OrigPacket) -> |
603 |
39 |
case try_to_create_room(From, To, Create0) of |
604 |
|
{ok, FinalRoomJid, Details} -> |
605 |
36 |
mod_muc_light_codec_backend:encode({set, Details, To#jid.luser == <<>>}, From, |
606 |
|
FinalRoomJid, make_handler_fun(Acc), Acc); |
607 |
|
{error, exists} -> |
608 |
2 |
mod_muc_light_codec_backend:encode_error({error, {conflict, <<"Room already exists">>}}, |
609 |
|
From, To, OrigPacket, |
610 |
|
Acc); |
611 |
|
{error, bad_request} -> |
612 |
:-( |
mod_muc_light_codec_backend:encode_error({error, bad_request}, From, To, OrigPacket, |
613 |
|
Acc); |
614 |
|
{error, {_, _} = Error} -> |
615 |
:-( |
ErrorText = io_lib:format("~s:~p", tuple_to_list(Error)), |
616 |
:-( |
mod_muc_light_codec_backend:encode_error( |
617 |
|
{error, bad_request, ErrorText}, From, To, OrigPacket, Acc); |
618 |
|
{error, Error} -> |
619 |
1 |
ErrorText = io_lib:format("~p", [Error]), |
620 |
1 |
mod_muc_light_codec_backend:encode_error( |
621 |
|
{error, bad_request, ErrorText}, From, To, OrigPacket, Acc) |
622 |
|
end. |
623 |
|
|
624 |
|
-spec process_create_aff_users_if_valid(HostType :: host_type(), |
625 |
|
Creator :: jid:simple_bare_jid(), |
626 |
|
AffUsers :: aff_users()) -> |
627 |
|
{ok, aff_users()} | {error, bad_request}. |
628 |
|
process_create_aff_users_if_valid(HostType, Creator, AffUsers) -> |
629 |
98 |
case lists:any(fun ({User, _}) when User =:= Creator -> true; |
630 |
36 |
({_, Aff}) -> Aff =:= none end, AffUsers) of |
631 |
|
false -> |
632 |
98 |
process_create_aff_users(Creator, AffUsers, equal_occupants(HostType)); |
633 |
|
true -> |
634 |
:-( |
{error, bad_request} |
635 |
|
end. |
636 |
|
|
637 |
|
equal_occupants(HostType) -> |
638 |
98 |
gen_mod:get_module_opt(HostType, ?MODULE, equal_occupants). |
639 |
|
|
640 |
|
-spec process_create_aff_users(Creator :: jid:simple_bare_jid(), AffUsers :: aff_users(), |
641 |
|
EqualOccupants :: boolean()) -> |
642 |
|
{ok, aff_users()} | {error, bad_request}. |
643 |
|
process_create_aff_users(Creator, AffUsers, EqualOccupants) -> |
644 |
98 |
case mod_muc_light_utils:change_aff_users([{Creator, creator_aff(EqualOccupants)}], AffUsers) of |
645 |
98 |
{ok, FinalAffUsers, _ChangedAffUsers, _JoiningUsers, _LeavingUsers} -> {ok, FinalAffUsers}; |
646 |
:-( |
Error -> Error |
647 |
|
end. |
648 |
|
|
649 |
|
-spec creator_aff(EqualOccupants :: boolean()) -> owner | member. |
650 |
2 |
creator_aff(true) -> member; |
651 |
96 |
creator_aff(false) -> owner. |
652 |
|
|
653 |
|
-spec handle_disco_info_get(From ::jid:jid(), |
654 |
|
To :: jid:jid(), |
655 |
|
DiscoInfo :: disco_info_req_props(), |
656 |
|
Acc :: mongoose_acc:t()) -> |
657 |
|
mongoose_acc:t(). |
658 |
|
handle_disco_info_get(From, To, DiscoInfo, Acc) -> |
659 |
4 |
mod_muc_light_codec_backend:encode({get, DiscoInfo}, From, To, |
660 |
|
make_handler_fun(Acc), Acc). |
661 |
|
|
662 |
|
-spec handle_disco_items_get(HostType :: host_type(), |
663 |
|
Acc :: mongoose_acc:t(), |
664 |
|
From ::jid:jid(), To ::jid:jid(), |
665 |
|
DiscoItems :: disco_items_req_props(), |
666 |
|
OrigPacket :: exml:element()) -> |
667 |
|
mongoose_acc:t(). |
668 |
|
handle_disco_items_get(HostType, Acc, From, To, DiscoItems0, OrigPacket) -> |
669 |
21 |
case catch mod_muc_light_db_backend:get_user_rooms(HostType, jid:to_lus(From), To#jid.lserver) of |
670 |
|
{error, Error} -> |
671 |
:-( |
?LOG_ERROR(#{what => muc_get_user_rooms_failed, |
672 |
|
text => <<"Couldn't get room list for user">>, |
673 |
:-( |
from_jid => From, reason => Error}), |
674 |
:-( |
mod_muc_light_codec_backend:encode_error( |
675 |
|
{error, internal_server_error}, From, To, OrigPacket, Acc); |
676 |
|
Rooms -> |
677 |
21 |
RoomsInfo = get_rooms_info(HostType, lists:sort(Rooms)), |
678 |
21 |
RouteFun = make_handler_fun(Acc), |
679 |
21 |
RoomsPerPage = gen_mod:get_module_opt(HostType, ?MODULE, rooms_per_page), |
680 |
21 |
case apply_rsm(RoomsInfo, length(RoomsInfo), |
681 |
|
page_service_limit(DiscoItems0#disco_items.rsm, RoomsPerPage)) of |
682 |
|
{ok, RoomsInfoSlice, RSMOut} -> |
683 |
19 |
DiscoItems = DiscoItems0#disco_items{ rooms = RoomsInfoSlice, rsm = RSMOut }, |
684 |
19 |
mod_muc_light_codec_backend:encode({get, DiscoItems}, |
685 |
|
From, To, |
686 |
|
RouteFun, Acc); |
687 |
|
{error, item_not_found} -> |
688 |
2 |
mod_muc_light_codec_backend:encode_error({error, item_not_found}, |
689 |
|
From, To, OrigPacket, Acc) |
690 |
|
end |
691 |
|
end. |
692 |
|
|
693 |
|
-spec get_rooms_info(HostType :: mongooseim:host_type(), |
694 |
|
Rooms :: [jid:simple_bare_jid()]) -> [disco_room_info()]. |
695 |
|
get_rooms_info(_HostType, []) -> |
696 |
37 |
[]; |
697 |
|
get_rooms_info(HostType, [{RoomU, _} = RoomUS | RRooms]) -> |
698 |
27 |
{ok, Config, Version} = mod_muc_light_db_backend:get_config(HostType, RoomUS), |
699 |
27 |
RoomName = case lists:keyfind(roomname, 1, Config) of |
700 |
2 |
false -> RoomU; |
701 |
25 |
{_, RoomName0} -> RoomName0 |
702 |
|
end, |
703 |
27 |
[{RoomUS, RoomName, Version} | get_rooms_info(HostType, RRooms)]. |
704 |
|
|
705 |
|
-spec apply_rsm(RoomsInfo :: [disco_room_info()], RoomsInfoLen :: non_neg_integer(), |
706 |
|
RSMIn :: jlib:rsm_in()) -> |
707 |
|
{ok, RoomsInfoSlice :: [disco_room_info()], RSMOut :: jlib:rsm_out()} | {error, item_not_found}. |
708 |
|
apply_rsm(RoomsInfo, _RoomsInfoLen, none) -> |
709 |
2 |
{ok, RoomsInfo, none}; |
710 |
|
apply_rsm(_RoomsInfo, _RoomsInfoLen, #rsm_in{ max = Max }) when Max < 0 -> |
711 |
:-( |
{error, item_not_found}; |
712 |
|
apply_rsm(_RoomsInfo, RoomsInfoLen, #rsm_in{ max = 0 }) -> |
713 |
:-( |
{ok, [], #rsm_out{ count = RoomsInfoLen }}; |
714 |
|
apply_rsm([], 0, #rsm_in{ direction = undefined, id = undefined, index = undefined } = _RSMIn) -> |
715 |
4 |
{ok, [], none}; |
716 |
|
apply_rsm(RoomsInfo, RoomsInfoLen, #rsm_in{ direction = undefined, id = undefined, |
717 |
|
index = undefined } = RSMIn) -> |
718 |
11 |
apply_rsm(RoomsInfo, RoomsInfoLen, RSMIn#rsm_in{ index = 0 }); |
719 |
|
apply_rsm(RoomsInfo, RoomsInfoLen, #rsm_in{ direction = before, id = <<>>, max = Max }) -> |
720 |
2 |
apply_rsm(RoomsInfo, RoomsInfoLen, #rsm_in{ max = Max, index = RoomsInfoLen - Max }); |
721 |
|
apply_rsm(RoomsInfo, RoomsInfoLen, #rsm_in{ index = undefined, direction = Direction, |
722 |
|
id = RoomUSBin, max = Max }) -> |
723 |
2 |
case find_room_pos(RoomUSBin, RoomsInfo) of |
724 |
|
{error, item_not_found} -> |
725 |
2 |
{error, item_not_found}; |
726 |
|
RoomPos -> |
727 |
:-( |
FirstPos = case {Direction, RoomPos - Max} of |
728 |
:-( |
{aft, _} -> RoomPos + 1; |
729 |
:-( |
{before, TooLow} when TooLow < 1 -> 1; |
730 |
:-( |
{before, FirstPos0} -> FirstPos0 |
731 |
|
end, |
732 |
:-( |
[{FirstRoomUS, _, _} | _] = RoomsInfoSlice = lists:sublist(RoomsInfo, FirstPos, Max), |
733 |
:-( |
{LastRoomUS, _, _} = lists:last(RoomsInfoSlice), |
734 |
:-( |
{ok, RoomsInfoSlice, #rsm_out{ count = RoomsInfoLen, |
735 |
|
index = FirstPos - 1, |
736 |
|
first = jid:to_binary(FirstRoomUS), |
737 |
|
last = jid:to_binary(LastRoomUS) }} |
738 |
|
end; |
739 |
|
apply_rsm(RoomsInfo, RoomsInfoLen, #rsm_in{ max = Max, index = Index}) when Index < RoomsInfoLen -> |
740 |
13 |
[{FirstRoomUS, _, _} | _] = RoomsInfoSlice = lists:sublist(RoomsInfo, Index + 1, Max), |
741 |
13 |
{LastRoomUS, _, _} = lists:last(RoomsInfoSlice), |
742 |
13 |
{ok, RoomsInfoSlice, #rsm_out{ count = RoomsInfoLen, |
743 |
|
index = Index, |
744 |
|
first = jid:to_binary(FirstRoomUS), |
745 |
|
last = jid:to_binary(LastRoomUS) }}; |
746 |
|
apply_rsm(_RoomsInfo, _RoomsInfoLen, _RSMIn) -> |
747 |
:-( |
{error, item_not_found}. |
748 |
|
|
749 |
|
-spec page_service_limit(RSMIn :: jlib:rsm_in() | undefined, ServiceMax :: integer()) -> |
750 |
|
jlib:rsm_in() | none. |
751 |
2 |
page_service_limit(none, infinity) -> none; |
752 |
15 |
page_service_limit(none, ServiceMax) -> #rsm_in{ max = ServiceMax }; |
753 |
:-( |
page_service_limit(#rsm_in{ max = Max } = RSMIn, ServiceMax) when Max =< ServiceMax -> RSMIn; |
754 |
4 |
page_service_limit(RSMIn, ServiceMax) -> RSMIn#rsm_in{ max = ServiceMax }. |
755 |
|
|
756 |
|
-spec find_room_pos(RoomUSBin :: binary(), RoomsInfo :: [disco_room_info()]) -> |
757 |
|
pos_integer() | {error, item_not_found}. |
758 |
|
find_room_pos(RoomUSBin, RoomsInfo) -> |
759 |
2 |
case jid:from_binary(RoomUSBin) of |
760 |
:-( |
error -> {error, item_not_found}; |
761 |
2 |
#jid{ luser = RoomU, lserver = RoomS } -> find_room_pos({RoomU, RoomS}, RoomsInfo, 1) |
762 |
|
end. |
763 |
|
|
764 |
|
-spec find_room_pos(RoomUS :: jid:simple_bare_jid(), RoomsInfo :: [disco_room_info()], |
765 |
|
Pos :: pos_integer()) -> pos_integer() | {error, item_not_found}. |
766 |
:-( |
find_room_pos(RoomUS, [{RoomUS, _, _} | _], Pos) -> Pos; |
767 |
4 |
find_room_pos(RoomUS, [_ | RRooms], Pos) -> find_room_pos(RoomUS, RRooms, Pos + 1); |
768 |
2 |
find_room_pos(_, [], _) -> {error, item_not_found}. |
769 |
|
|
770 |
|
-spec handle_blocking(Acc :: mongoose_acc:t(), From :: jid:jid(), To :: jid:jid(), |
771 |
|
BlockingReq :: {get | set, blocking_req_props()}) -> |
772 |
|
{error, bad_request} | ok. |
773 |
|
handle_blocking(Acc, From, To, {get, #blocking{} = Blocking}) -> |
774 |
3 |
HostType = mongoose_acc:host_type(Acc), |
775 |
3 |
BlockingItems = mod_muc_light_db_backend:get_blocking(HostType, jid:to_lus(From), To#jid.lserver), |
776 |
3 |
mod_muc_light_codec_backend:encode({get, Blocking#blocking{ items = BlockingItems }}, |
777 |
|
From, To, make_handler_fun(Acc), Acc); |
778 |
|
handle_blocking(Acc, From, To, {set, #blocking{ items = Items }} = BlockingReq) -> |
779 |
8 |
case lists:any(fun({_, _, {WhoU, WhoS}}) -> WhoU =:= <<>> orelse WhoS =:= <<>> end, Items) of |
780 |
|
true -> |
781 |
:-( |
{error, bad_request}; |
782 |
|
false -> |
783 |
8 |
HostType = mongoose_acc:host_type(Acc), |
784 |
8 |
ok = mod_muc_light_db_backend:set_blocking(HostType, jid:to_lus(From), To#jid.lserver, Items), |
785 |
8 |
mod_muc_light_codec_backend:encode( |
786 |
|
BlockingReq, From, To, make_handler_fun(Acc), Acc), |
787 |
8 |
ok |
788 |
|
end. |
789 |
|
|
790 |
|
-spec bcast_removed_user(Acc :: mongoose_acc:t(), UserJid :: jid:jid(), |
791 |
|
AffectedRooms :: mod_muc_light_db_backend:remove_user_return(), |
792 |
|
Version :: binary()) -> ok. |
793 |
|
bcast_removed_user(Acc, UserJid, AffectedRooms, Version) -> |
794 |
139 |
bcast_removed_user(Acc, UserJid, AffectedRooms, |
795 |
|
Version, mongoose_bin:gen_from_timestamp()). |
796 |
|
|
797 |
|
-spec bcast_removed_user(Acc :: mongoose_acc:t(), UserJID :: jid:jid(), |
798 |
|
AffectedRooms :: mod_muc_light_db_backend:remove_user_return(), |
799 |
|
Version :: binary(), |
800 |
|
PacketID :: binary()) -> ok. |
801 |
|
bcast_removed_user(_Acc, _UserJID, [], _Version, _ID) -> |
802 |
139 |
ok; |
803 |
|
bcast_removed_user(Acc, UserJID, |
804 |
|
[{{RoomU, RoomS}, {ok, OldAffUsers, NewAffUsers, AffUsersChanged, PrevVersion}} |
805 |
|
| RAffected], Version, ID) -> |
806 |
79 |
Affiliations = #affiliations{ |
807 |
|
id = ID, |
808 |
|
prev_version = PrevVersion, |
809 |
|
version = Version, |
810 |
|
aff_users = AffUsersChanged |
811 |
|
}, |
812 |
79 |
Cmd = {set, Affiliations, OldAffUsers, NewAffUsers}, |
813 |
79 |
RoomJid = jid:make_noprep(RoomU, RoomS, <<>>), |
814 |
79 |
mod_muc_light_codec_backend:encode(Cmd, UserJID, RoomJid, make_handler_fun(Acc), Acc), |
815 |
79 |
bcast_removed_user(Acc, UserJID, RAffected, Version, ID); |
816 |
|
bcast_removed_user(Acc, UserJID, [{{RoomU, RoomS} = _RoomUS, Error} | RAffected], Version, ID) -> |
817 |
:-( |
?LOG_ERROR(#{what => muc_remove_user_failed, |
818 |
|
user_jid => jid:to_binary(UserJID), room => RoomU, sub_host => RoomS, |
819 |
:-( |
reason => Error}), |
820 |
:-( |
bcast_removed_user(Acc, UserJID, RAffected, Version, ID). |
821 |
|
|
822 |
|
-spec maybe_forget_rooms(Acc :: mongoose_acc:t(), |
823 |
|
AffectedRooms :: mod_muc_light_db_backend:remove_user_return(), |
824 |
|
Version :: binary()) -> ok. |
825 |
|
maybe_forget_rooms(_Acc, [], _) -> |
826 |
139 |
ok; |
827 |
|
maybe_forget_rooms(Acc, [{RoomUS, {ok, _, NewAffUsers, _, _}} | RAffectedRooms], Version) -> |
828 |
79 |
mod_muc_light_room:maybe_forget(Acc, RoomUS, NewAffUsers, Version), |
829 |
79 |
maybe_forget_rooms(Acc, RAffectedRooms, Version). |
830 |
|
|
831 |
|
make_handler_fun(Acc) -> |
832 |
151 |
fun(From, To, Packet) -> ejabberd_router:route(From, To, Acc, Packet) end. |
833 |
|
|
834 |
|
config_metrics(Host) -> |
835 |
:-( |
OptsToReport = [{backend, mnesia}], %list of tuples {option, defualt_value} |
836 |
:-( |
mongoose_module_metrics:opts_for_module(Host, ?MODULE, OptsToReport). |