25
1
mirror of https://github.com/processone/ejabberd.git synced 2024-10-31 15:21:38 +01:00
xmpp.chapril.org-ejabberd/mod_pubsub_ng/pubsub_db_mnesia.erl

2130 lines
81 KiB
Erlang

%%% ====================================================================
%%% ``The contents of this file are subject to the Erlang Public License,
%%% Version 1.1, (the "License"); you may not use this file except in
%%% compliance with the License. You should have received a copy of the
%%% Erlang Public License along with this software. If not, it can be
%%% retrieved via the world wide web at http:%%www.erlang.org/.
%%%
%%% Software distributed under the License is distributed on an "AS IS"
%%% basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
%%% the License for the specific language governing rights and limitations
%%% under the License.
%%%
%%% The Initial Developer of the Original Code is ProcessOne.
%%% Portions created by ProcessOne are Copyright 2006-2013, ProcessOne
%%% All Rights Reserved.''
%%% This software is copyright 2006-2013, ProcessOne.
%%%
%%% @copyright 2006-2013 ProcessOne
%%% @author Karim Gemayel <karim.gemayel@process-one.net>
%%% [http:%%www.process-one.net/]
%%% @version {@vsn}, {@date} {@time}
%%% @end
%%% ====================================================================
%%% @headerfile "pubsub_dev.hrl"
-module(pubsub_db_mnesia).
-author('karim.gemayel@process-one.net').
-compile(export_all).
-include("pubsub_dev.hrl").
-include("pubsub_api.hrl").
-import(pubsub_tools,
[
get_option/2,
get_option/3,
get_value/2,
get_value/3,
set_value/3,
%%
check_access_model/3,
check_access_model/7,
check_publish_model/3,
is_contact_subscribed_to_node_owners/3,
is_contact_in_allowed_roster_groups/2,
has_subscriptions/1
]).
-export_type([
suffix/0,
table/0
]).
-type(suffix() :: undefined | atom()).
-type(table() :: atom()).
%%
-spec(init/1 ::
(
Suffix :: undefined | atom())
-> 'ok'
).
init(Suffix) ->
create_table_pubsub_node(Suffix),
create_table_pubsub_state(Suffix),
create_table_pubsub_item(Suffix),
create_table_pubsub_last_item(Suffix),
create_table_pubsub_subscription_pending(Suffix),
pubsub_index_dev:init(Suffix),
pubsub_groups:create_table_pubsub_groups(Suffix).
%%
-spec(table/2 ::
(
Base_Table :: atom(),
Suffix :: undefined | atom())
-> Table :: atom()
).
table(Base_Table, undefined = _Suffix) ->
_Table = Base_Table;
table(Base_Table, Suffix) ->
_Table = list_to_atom(atom_to_list(Base_Table) ++ "_" ++ atom_to_list(Suffix)).
%%
create_table_pubsub_node(Suffix) ->
mnesia:create_table(table('pubsub_node', Suffix),
[{type, set},
{disc_copies, [node()]},
{record_name, pubsub_node_dev},
{attributes, record_info(fields, pubsub_node_dev)}]),
mnesia:add_table_index(pubsub_node_dev, idx).
create_table_pubsub_state(Suffix) ->
mnesia:create_table(table('pubsub_state', Suffix),
[{type, set},
{disc_copies, [node()]},
{record_name, pubsub_state_dev},
{attributes, record_info(fields, pubsub_state_dev)}]),
mnesia:add_table_index(pubsub_state_dev, nodeidx).
create_table_pubsub_item(Suffix) ->
mnesia:create_table(table('pubsub_item', Suffix),
[{type, set},
{disc_copies, [node()]},
{record_name, pubsub_item_dev},
{attributes, record_info(fields, pubsub_item_dev)}]),
mnesia:add_table_index(pubsub_item_dev, nodeidx).
create_table_pubsub_last_item(Suffix) ->
mnesia:create_table(table('pubsub_last_item', Suffix),
[{type, set},
{disc_copies, [node()]},
{record_name, pubsub_last_item_dev},
{attributes, record_info(fields, pubsub_last_item_dev)}]).
create_table_pubsub_subscription_pending(Suffix) ->
mnesia:create_table(table('pubsub_subscription_pending', Suffix),
[{type, set},
{disc_copies, [node()]},
{record_name, pubsub_subscription_pending},
{attributes, record_info(fields, pubsub_subscription_pending)}]),
mnesia:add_table_index(pubsub_subscription_pending, nodeidx).
%%
transaction(Module, Function, Arguments) ->
case mnesia:transaction(fun() -> apply(Module, Function, Arguments) end) of
{atomic, Result} ->
Result;
{aborted, Reason} ->
?INFO_MSG("DB TRANSACTION ERROR ~p", [Reason]),
{error, 'internal-server-error'}
end.
%%
-spec(read_item/3 ::
(
Suffix :: atom(),
NodeIdx :: exmpp_pubsub:nodeIdx(),
ItemId :: exmpp_pubsub:itemId())
-> Pubsub_Item :: undefined | mod_pubsub_dev:pubsub_item()
).
read_item(Suffix, NodeIdx, ItemId) ->
_Pubsub_Item = case
mnesia:read({_Table = table('pubsub_item', Suffix), {ItemId, NodeIdx}})
of
[Pubsub_Item] -> Pubsub_Item;
[] -> undefined
end.
%%
-spec(read_node/3 ::
(
Suffix :: atom(),
Pubsub_Host :: exmpp_pubsub:host(),
NodeId :: exmpp_pubsub:nodeId())
-> Pubsub_Node :: undefined | mod_pubsub_dev:pubsub_node()
).
read_node(Suffix, Pubsub_Host, NodeId) ->
_Pubsub_Node = case
mnesia:read({_Table = table('pubsub_node', Suffix),
{Pubsub_Host, NodeId}})
of
[Pubsub_Node] -> Pubsub_Node;
[] -> undefined
end.
%%
-spec(read_state/3 ::
(
Suffix :: atom(),
Entity :: xmpp_jid:usr_entity(),
NodeIdx :: exmpp_pubsub:nodeIdx())
-> Pubsub_State :: undefined | mod_pubsub_dev:pubsub_state()
).
read_state(Suffix, {U,S,_R} = _Entity, NodeIdx) ->
_Pubsub_State = case
mnesia:read({_Table = table('pubsub_state', Suffix),
{{U,S,undefined}, NodeIdx}})
of
[Pubsub_State] -> Pubsub_State;
[] -> undefined
end.
%%
-spec(index_read_node/2 ::
(
Suffix :: atom(),
NodeIdx :: exmpp_pubsub:nodeIdx())
-> Pubsub_Nodes::[Pubsub_Node::mod_pubsub_dev:pubsub_node()]
).
index_read_node(Suffix, NodeIdx) ->
_Pubsub_Nodes = mnesia:index_read(_Table = table('pubsub_node', Suffix),
NodeIdx, idx).
%%
-spec(index_read_state/2 ::
(
Suffix :: atom(),
NodeIdx :: exmpp_pubsub:nodeIdx())
-> Pubsub_States::[Pubsub_State::mod_pubsub_dev:pubsub_state()]
).
index_read_state(Suffix, NodeIdx) ->
_Pubsub_States = mnesia:index_read(_Table = table('pubsub_state', Suffix),
NodeIdx, nodeidx).
%-- Create_Node --%
-spec(create_node/7 ::
(
Suffix :: atom(),
Pubsub_Host :: exmpp_pubsub:host(),
Entity :: xmpp_jid:usr_entity(),
NodeId :: exmpp_pubsub:nodeId(),
Level :: exmpp_pubsub:level(),
Node_Options :: pubsub_options:options_node(),
Pubsub_Features :: exmpp_pubsub:pubsub_features())
-> Subscription :: undefined | exmpp_pubsub:subscription_subscribed()
).
create_node(Suffix, Pubsub_Host, {U,S,R} = _Entity, NodeId, Level, Node_Options,
Pubsub_Features) ->
%% Create Pubsub_Node
mnesia:write(table('pubsub_node', Suffix),
#pubsub_node_dev{
id = {Pubsub_Host, NodeId},
idx = NodeIdx = pubsub_index_dev:new(Suffix, 'node'),
level = Level,
creation = {_DateTime = now(), _Creator = {U,S,R}},
owners = [{U,S,undefined}],
options = Node_Options
},
write),
_Subscription = case
lists:member(<<"auto-subscribe">>, Pubsub_Features)
andalso
get_value(Node_Options, 'subscribe', false)
of
true ->
mnesia:write(table('pubsub_state', Suffix),
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
affiliation = 'owner',
subscriptions = [Subscription = {
_Subscription_State = 'subscribed',
_SubId = exmpp_pubsub:subId(),
_Resource = undefined,
_Subscription_Options = []
}]
},
write),
Subscription;
false ->
mnesia:write(table('pubsub_state', Suffix),
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
affiliation = 'owner'
},
write),
undefined
end.
%-- Purge_Node --%
%% TODO : purge Pubsub_Purge_Offline
%% TODO : purge Pubsub_Expiry_Item
-spec(purge_node/2 ::
(
Suffix :: atom(),
Pubsub_Node :: mod_pubsub_dev:pubsub_node())
-> Recipients :: undefined | [Entity::xmpp_jid:usr_bare()]
).
purge_node(Suffix, Pubsub_Node) ->
%% Update Pubsub_Node
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{itemids = []}, write),
%% Delete Pubsub_Last_Item
mnesia:delete(table('pubsub_last_item', Suffix),
NodeIdx = Pubsub_Node#pubsub_node_dev.idx, write),
%%
Table_Pubsub_State = table('pubsub_state', Suffix),
Table_Pubsub_Item = table('pubsub_item', Suffix),
_Recipients = case
get_value(Pubsub_Node#pubsub_node_dev.options, 'notify_retract', false)
of
true ->
%% Delete Pubsub_Items
lists:foreach(fun
(Pubsub_Item) ->
mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write)
%
end, _Pubsub_Items = mnesia:index_read(Table_Pubsub_Item, NodeIdx,
nodeidx)),
%% Update Pubsub_States
_Subscribers = lists:foldl(fun
%%
(Pubsub_State, Subscribers)
when (Pubsub_State#pubsub_state_dev.affiliation == 'owner'
orelse
Pubsub_State#pubsub_state_dev.affiliation == 'outcast'
orelse
Pubsub_State#pubsub_state_dev.affiliation == 'publish-only')
andalso Pubsub_State#pubsub_state_dev.itemids =/= [] ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{itemids = []},
write),
Subscribers;
%%
(#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
Subscribers)
when Pubsub_State#pubsub_state_dev.affiliation == 'publisher'
andalso Pubsub_State#pubsub_state_dev.itemids =/= [] ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{itemids = []}, write),
case Pubsub_State#pubsub_state_dev.subscriptions of
[] = _Subscriptions ->
Subscribers;
_Subscriptions ->
[_Subscriber = Entity | Subscribers]
end;
%%
(#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
Subscribers)
when Pubsub_State#pubsub_state_dev.affiliation == 'publisher'
andalso Pubsub_State#pubsub_state_dev.subscriptions =/= [] ->
[_Subscriber = Entity | Subscribers];
%%
(#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
Subscribers)
when Pubsub_State#pubsub_state_dev.affiliation == 'member'
andalso Pubsub_State#pubsub_state_dev.itemids =/= [] ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{itemids = []}, write),
case
(Pubsub_State#pubsub_state_dev.subscriptions == []
orelse
has_subscriptions(
Pubsub_State#pubsub_state_dev.subscriptions))
of
true -> [_Subscriber = Entity | Subscribers];
false -> Subscribers
end;
%%
(#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
Subscribers)
when Pubsub_State#pubsub_state_dev.affiliation == 'member'->
case
(Pubsub_State#pubsub_state_dev.subscriptions == []
orelse
has_subscriptions(
Pubsub_State#pubsub_state_dev.subscriptions))
of
true -> [_Subscriber = Entity | Subscribers];
false -> Subscribers
end;
%%
(_Pubsub_State, Subscribers) ->
Subscribers
%
end,
[],
_Pubsub_States = mnesia:index_read(Table_Pubsub_State,
NodeIdx, nodeidx));
false ->
%% Update Pubsub_States
lists:foreach(fun
(_Items_Owner = Entity) ->
case
mnesia:read(Table_Pubsub_State, {Entity, NodeIdx},
write)
of
[Pubsub_State]
when Pubsub_State#pubsub_state_dev.itemids =/= [] ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{itemids = []},
write);
_Pubsub_State ->
ok
end
end,
_Items_Owners = lists:foldl(fun
%% Delete Pubsub_Items
(Pubsub_Item, Items_Owners) ->
mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item,
write),
lists:usort(lists:append(Items_Owners,
Pubsub_Item#pubsub_item_dev.owners))
end, [],
_Pubsub_Items = mnesia:index_read(Table_Pubsub_Item, NodeIdx,
nodeidx))
),
_Subscribers = undefined
end.
%-- Delete_Node --%
-spec(delete_node/2 ::
(
Suffix :: atom(),
Pubsub_Node :: mod_pubsub_dev:pubsub_node())
-> Recipients :: undefined | [Entity::xmpp_jid:usr_bare()]
).
delete_node(Suffix, Pubsub_Node) ->
%% Delete Pubsub_Node
mnesia:delete_object(table('pubsub_node', Suffix), Pubsub_Node, write),
pubsub_index_dev:free(Suffix, 'node',
NodeIdx = Pubsub_Node#pubsub_node_dev.idx),
%% Delete Pubsub_Last_Item
mnesia:delete(table('pubsub_last_item', Suffix), NodeIdx, write),
%% Delete Pubsub_Items
Table_Pubsub_Item = table('pubsub_item', Suffix),
lists:foreach(fun
(Pubsub_Item) ->
mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write)
%
end,
_Pubsub_Items = mnesia:index_read(Table_Pubsub_Item, NodeIdx,
nodeidx)),
%% Delete Pubsub_States
Table_Pubsub_State = table('pubsub_state', Suffix),
_Recipients = case
get_value(Pubsub_Node#pubsub_node_dev.options, 'notify_delete', false)
of
true ->
_Subscribers = lists:foldl(fun
(#pubsub_state_dev{id = {Entity, _NodeIdx}} = Pubsub_State,
Subscribers) ->
mnesia:delete_object(Table_Pubsub_State, Pubsub_State,
write),
case
{Pubsub_State#pubsub_state_dev.affiliation,
Pubsub_State#pubsub_state_dev.subscriptions}
of
%%
{'publisher' = _Affiliation, Subscriptions}
when Subscriptions =/= [] ->
[_Subscriber = Entity | Subscribers];
%%
{'member' = _Affiliation, _Subscriptions} ->
case
(_Subscriptions == []
orelse
has_subscriptions(_Subscriptions))
of
true ->
[_Subscriber = Entity | Subscribers];
false ->
Subscribers
end;
%%
{_Affiliation, _Subscriptions} ->
Subscribers
end
%
end, [],
_Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx,
nodeidx));
false ->
lists:foreach(fun
(Pubsub_State) ->
mnesia:delete_object(Table_Pubsub_State, Pubsub_State,
write)
end,
_Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx,
nodeidx)),
_Subscribers = undefined
end.
%-- Get_Entity_Subscriptions --%
-spec(get_entity_subscriptions/4 ::
(
Suffix :: atom(),
Pubsub_Host :: exmpp_pubsub:host(),
Entity :: xmpp_jid:usr_entity(),
NodeId :: undefined | exmpp_pubsub:nodeId())
-> Entity_Subscriptions :: [{
NodeId :: exmpp_pubsub:nodeId(),
Subscriptions :: exmpp_pubsub:subscriptions()
}]
).
get_entity_subscriptions(Suffix, Pubsub_Host, {U,S,_R} = _Entity,
undefined = _NodeId) ->
Table_Pubsub_Node = table('pubsub_node', Suffix),
_Entity_Subscriptions = lists:foldl(fun
([NodeIdx, Subscriptions], Entity_Subscriptions) ->
case mnesia:index_read(Table_Pubsub_Node, NodeIdx, idx) of
%% IMPORTANT : Pubsub_Host must be used in the matching,
%% else it'd return all NodeIds subscriptions (in case of VHosts)
%% and not only the ones from to the current Pubsub_Host
[#pubsub_node_dev{id = {Pubsub_Host, NodeId}}] ->
[{NodeId, Subscriptions} | Entity_Subscriptions];
_Pubsub_Node ->
Entity_Subscriptions
end
end, [],
mnesia:select(table('pubsub_state', Suffix),
[{#pubsub_state_dev{
id = {{U,S,undefined}, '$1'},
subscriptions = '$2',
_ = '_'},
[{'=/=', '$2', []}],
['$$']}]));
%%
get_entity_subscriptions(Suffix, Pubsub_Host, {U,S,_R} = _Entity, NodeId) ->
_Entity_Subscriptions = case
mnesia:read(table('pubsub_node', Suffix), {Pubsub_Host, NodeId}, read)
of
[] ->
[];
[#pubsub_node_dev{idx = NodeIdx}] ->
case
mnesia:read(table('pubsub_state', Suffix),
{{U,S,undefined}, NodeIdx}, read)
of
[#pubsub_state_dev{subscriptions = Subscriptions}]
when Subscriptions =/= [] ->
[{NodeId, Subscriptions}];
_Pubsub_State ->
[]
end
end.
%-- Get_Entity_Affiliations --%
-spec(get_entity_affiliations/4 ::
(
Suffix :: atom(),
Pubsub_Host :: exmpp_pubsub:host(),
Entity :: xmpp_jid:usr_bare(),
NodeId :: undefined | exmpp_pubsub:nodeId())
-> Entity_Affiliations :: [Entity_Affiliation :: {
NodeId :: exmpp_pubsub:nodeId(),
Affiliation :: exmpp_pubsub:affiliation()
}]
).
get_entity_affiliations(Suffix, Pubsub_Host, {U,S,_R} = _Entity,
undefined = _NodeId) ->
Table_Pubsub_Node = table('pubsub_node', Suffix),
_Entity_Affiliations = lists:foldl(fun
([NodeIdx, Affiliation], Entity_Affiliations) ->
case mnesia:index_read(Table_Pubsub_Node, NodeIdx, idx) of
%% IMPORTANT : Pubsub_Host must be used in the matching,
%% else it'd return all NodeIds affiliations (in case of VHosts)
%% and not only the ones from to the current Pubsub_Host
[#pubsub_node_dev{id = {Pubsub_Host, NodeId}}] ->
[{NodeId, Affiliation} | Entity_Affiliations];
_Pubsub_Node ->
Entity_Affiliations
end
end, [],
mnesia:select(table('pubsub_state', Suffix),
[{#pubsub_state_dev{
id = {{U,S,undefined}, '$1'},
affiliation = '$2',
_ = '_'},
[],
['$$']}],
read)
);
%%
get_entity_affiliations(Suffix, Pubsub_Host, {U,S,_R} = _Entity, NodeId) ->
_Entity_Affiliations = case
mnesia:read(table('pubsub_node', Suffix), {Pubsub_Host, NodeId}, read)
of
[] ->
[];
[#pubsub_node_dev{idx = NodeIdx}] ->
case
mnesia:read(table('pubsub_state', Suffix),
{{U,S,undefined}, NodeIdx})
of
[#pubsub_state_dev{affiliation = Affiliation}] ->
[{NodeId, Affiliation}];
_Pubsub_State ->
[]
end
end.
%-- Publish_Item --%
-spec(publish_item1/9 ::
(
Suffix :: atom(),
Pubsub_Host :: exmpp_pubsub:host(),
Entity :: xmpp_jid:usr_entity(),
NodeId :: undefined | exmpp_pubsub:nodeId(),
Level :: exmpp_pubsub:level(),
ItemId :: undefined | exmpp_pubsub:itemId(),
Payload :: [Xmlel::#xmlel{}] | exmpp_pubsub:payload(),
Options :: {Node_Options :: pubsub_options:options_node(),
Item_Options :: [] | pubsub_options:options_item()},
Pubsub_Features :: exmpp_pubsub:pubsub_features())
-> {ItemId :: exmpp_pubsub:itemId(),
Pubsub_State@Owner :: mod_pubsub_dev:pubsub_state_owner()}
).
publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level, ItemId,
[Payload], Options, Pubsub_Features) ->
publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level, ItemId, Payload,
Options, Pubsub_Features);
publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level, undefined = _ItemId,
Payload, Options, Pubsub_Features) ->
publish_item1(Suffix, Pubsub_Host, Entity, NodeId, Level,
exmpp_pubsub:itemId(), Payload, Options, Pubsub_Features);
%%
publish_item1(Suffix, Pubsub_Host, {U,S,R} = _Entity, NodeId, Level, ItemId,
Payload, {Node_Options, Item_Options} = Options, Pubsub_Features) ->
NodeIdx = pubsub_index_dev:new(Suffix, 'node'),
DateTime = now(),
Write_Item = get_value(Options, 'persist_items', false) andalso
(get_value(Node_Options, 'max_items', 0) > 0),
%% Create Pubsub_Node
mnesia:write(table('pubsub_node', Suffix),
#pubsub_node_dev{
id = {Pubsub_Host, NodeId},
idx = NodeIdx,
creation = {DateTime, _Creator = {U,S,R}},
level = Level,
owners = [{U,S,undefined}],
itemids = case Write_Item of
true -> [ItemId];
false -> []
end,
options = Node_Options
},
write),
%% Create Pubsub_Item
case Write_Item of
false ->
ok;
true ->
mnesia:write(table('pubsub_item', Suffix),
#pubsub_item_dev{
id = {ItemId, NodeIdx},
nodeidx = NodeIdx,
owners = [{U,S,undefined}],
creation = {DateTime, _Creator = {U,S,R}},
payload = Payload,
options = Item_Options
},
write),
%%TODO : Register pubsub#item_expire
case get_value(Options, 'item_expire', undefined) of
undefined ->
ko;
Delay ->
ok
end
end,
%% Create Pubsub_Last_Item
case get_value(Options, 'send_last_published_item', 'never') of
'never' ->
ok;
_Send_Last_Published_Item ->
mnesia:write(table('pubsub_last_item', Suffix),
#pubsub_last_item_dev{
nodeidx = NodeIdx,
id = ItemId,
owners = [{U,S,undefined}],
creation = {DateTime, _Creator = {U,S,R}},
payload = Payload,
options = Item_Options
},
write)
end,
%% Create Pubsub_State
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State = #pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
itemids = case Write_Item of
true -> [ItemId];
false -> []
end,
affiliation = 'owner',
subscriptions = case
lists:member(<<"auto-subscribe">>, Pubsub_Features)
andalso
get_value(Node_Options, 'subscribe', false)
of
true ->
[{_Subscription_State = 'subscribed',
_SubId = exmpp_pubsub:subId(),
_Resource = undefined,
_Subscription_Options = []}];
false ->
[]
end
},
write),
{ItemId, Pubsub_State}.
%%
-spec(publish_item2/9 ::
(
Suffix :: atom(),
Pubsub_Host :: exmpp_pubsub:host(),
Entity :: xmpp_jid:usr_entity(),
Pubsub_State :: undefined | mod_pubsub_dev:pubsub_state(),
Pubsub_Node :: mod_pubsub_dev:pubsub_node(),
_ :: undefined | exmpp_pubsub:itemId() | mod_pubsub_dev:pubsub_item(),
Payload :: [Xmlel::#xmlel{}] | exmpp_pubsub:payload(),
Options :: {Node_Options :: pubsub_options:options_node(),
Item_Options :: [] | pubsub_options:options_item()},
Pubsub_Features :: exmpp_pubsub:pubsub_features())
-> {ItemId :: exmpp_pubsub:itemId(),
Retracted_Items :: [Retracted_Item::{
ItemId :: exmpp_pubsub:itemId(),
Item_Options :: [] | pubsub_options:options_node()
}],
Pubsub_States :: [Pubsub_State::mod_pubsub_dev:pubsub_state(),...]}
).
publish_item2(Suffix, Pubsub_Host, Entity, Pubsub_State, Pubsub_Node, Pubsub_Item,
[Payload], Item_Options, Pubsub_Features) ->
publish_item2(Suffix, Pubsub_Host, Entity, Pubsub_State, Pubsub_Node,
Pubsub_Item, Payload, Item_Options, Pubsub_Features);
%%
publish_item2(Suffix, Pubsub_Host, {U,S,R} = _Entity, Pubsub_State, Pubsub_Node,
#pubsub_item_dev{id = {ItemId, NodeIdx}} = Pubsub_Item, Payload, Item_Options,
Pubsub_Features) ->
Node_Options = Pubsub_Node#pubsub_node_dev.options,
DateTime = now(),
Table_Pubsub_State = table('pubsub_state', Suffix),
_Retracted_Items = case
{get_value(Node_Options, 'persist_items', false),
get_value(Node_Options, 'max_items', 0)}
of
%%
{Persist_Items, Max_Items}
when Persist_Items == false
orelse Max_Items == 0 ->
case Pubsub_State of
undefined ->
mnesia:write(table('pubsub_state', Suffix),
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx
},
write),
[];
_Pubsub_State ->
[]
end;
%%
{true, undefined} ->
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{
itemids = lists:reverse([ItemId
| lists:reverse(lists:delete(ItemId,
Pubsub_Node#pubsub_node_dev.itemids))])
},
write),
%%
mnesia:write(Table_Pubsub_State,
case Pubsub_State of
undefined ->
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
itemids = [ItemId]
};
_ ->
Pubsub_State#pubsub_state_dev{
itemids = [ItemId | lists:delete(ItemId,
Pubsub_State#pubsub_state_dev.itemids)]
}
end,
write),
mnesia:write(table('pubsub_item', Suffix),
Pubsub_Item#pubsub_item_dev{
modification = {DateTime, {U,S,R}},
payload = Payload,
options = Item_Options,
owners = [{U,S,undefined} |
lists:delete({U,S,undefined},
Pubsub_Item#pubsub_item_dev.owners)]
},
write),
[];
{true, Max_Items} ->
{New_ItemIds, Old_ItemIds} = max_items(Max_Items,
lists:reverse([ItemId
| lists:reverse(lists:delete(ItemId,
Pubsub_Node#pubsub_node_dev.itemids))])),
{Retracted_Items, Publisher_Retracted_ItemIds} =
delete_old_items(Suffix,
_Publisher = {U,S,undefined},
NodeIdx,
_Notify_Retract = get_value(Node_Options,
'notify_retract', false),
Old_ItemIds, {[], {[], []}}),
%%
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{
itemids = New_ItemIds
},
write),
mnesia:write(table('pubsub_item', Suffix),
Pubsub_Item#pubsub_item_dev{
modification = {DateTime, {U,S,R}},
payload = Payload,
options = Item_Options,
owners = [{U,S,undefined} |
lists:delete({U,S,undefined},
Pubsub_Item#pubsub_item_dev.owners)]
},
write),
mnesia:write(Table_Pubsub_State,
case Pubsub_State of
undefined ->
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
itemids = [ItemId]
};
_ ->
Pubsub_State#pubsub_state_dev{
itemids = [ItemId
| lists:foldl(fun
(Publisher_Retracted_ItemId,
Publisher_ItemIds) ->
lists:delete(
Publisher_Retracted_ItemId,
Publisher_ItemIds)
end,
lists:delete(ItemId,
Pubsub_State#pubsub_state_dev.itemids),
Publisher_Retracted_ItemIds)]
}
end,
write),
Retracted_Items
end,
case get_value(Node_Options, 'send_last_published_item', 'never') of
'never' ->
ok;
_Send_Last_Published_Item ->
mnesia:write(table('pubsub_last_item', Suffix),
#pubsub_last_item_dev{
nodeidx = NodeIdx,
id = ItemId,
owners = [{U,S,undefined}],
creation = {DateTime, _Creator = {U,S,R}},
payload = Payload,
options = Item_Options
},
write)
end,
{ItemId, _Retracted_Items,
_Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)};
%%
publish_item2(Suffix, Pubsub_Host, {U,S,R} = Entity, Pubsub_State, Pubsub_Node,
_ItemId, Payload, Item_Options, Pubsub_Features) ->
NodeIdx = Pubsub_Node#pubsub_node_dev.idx,
Node_Options = Pubsub_Node#pubsub_node_dev.options,
ItemId = case _ItemId of
undefined -> exmpp_pubsub:itemId();
_ -> _ItemId
end,
DateTime = now(),
Table_Pubsub_State = table('pubsub_state', Suffix),
_Retracted_Items = case
{get_value(Node_Options, 'persist_items', false),
get_value(Node_Options, 'max_items', 0)}
of
%%
{Persist_Items, Max_Items}
when Persist_Items == false
orelse Max_Items == 0 ->
case Pubsub_State of
undefined ->
mnesia:write(Table_Pubsub_State,
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx
},
write),
[];
_Pubsub_State ->
[]
end;
%%
{true, undefined} ->
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{
itemids = lists:reverse([ItemId
| lists:reverse(ItemId,
Pubsub_Node#pubsub_node_dev.itemids)])
},
write),
%%
mnesia:write(Table_Pubsub_State,
case Pubsub_State of
undefined ->
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
itemids = [ItemId]
};
_ ->
Pubsub_State#pubsub_state_dev{
itemids = [ItemId |
Pubsub_State#pubsub_state_dev.itemids]
}
end,
write),
mnesia:write(table('pubsub_item', Suffix),
#pubsub_item_dev{
id = {ItemId, NodeIdx},
nodeidx = NodeIdx,
owners = [{U,S,undefined}],
creation = {DateTime, {U,S,R}},
payload = Payload,
options = Item_Options
},
write),
[];
{true, Max_Items} ->
{New_ItemIds, Old_ItemIds} = max_items(Max_Items,
lists:reverse([ItemId
| lists:reverse(Pubsub_Node#pubsub_node_dev.itemids)])),
{Retracted_Items, Publisher_Retracted_ItemIds} =
delete_old_items(Suffix,
_Publisher = {U,S,undefined},
NodeIdx,
_Notify_Retract = get_value(Node_Options,
'notify_retract', false),
Old_ItemIds, {[], {[], []}}),
%%
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{
itemids = New_ItemIds
},
write),
mnesia:write(table('pubsub_item', Suffix),
#pubsub_item_dev{
id = {ItemId, NodeIdx},
nodeidx = NodeIdx,
owners = [{U,S,undefined}],
creation = {DateTime, {U,S,R}},
payload = Payload,
options = Item_Options
},
write),
%%
mnesia:write(Table_Pubsub_State,
case Pubsub_State of
undefined ->
#pubsub_state_dev{
id = {{U,S,undefined}, NodeIdx},
nodeidx = NodeIdx,
itemids = [ItemId]
};
_ ->
Pubsub_State#pubsub_state_dev{
itemids = [ItemId
| lists:foldl(fun
(Publisher_Retracted_ItemId,
Publisher_ItemIds) ->
lists:delete(
Publisher_Retracted_ItemId,
Publisher_ItemIds)
end,
Pubsub_State#pubsub_state_dev.itemids,
Publisher_Retracted_ItemIds)]
}
end,
write),
Retracted_Items
end,
case get_value(Node_Options, 'send_last_published_item', 'never') of
'never' ->
ok;
_Send_Last_Published_Item ->
mnesia:write(table('pubsub_last_item', Suffix),
#pubsub_last_item_dev{
nodeidx = NodeIdx,
id = ItemId,
owners = [{U,S,undefined}],
creation = {DateTime, _Creator = {U,S,R}},
payload = Payload,
options = Item_Options
},
write)
end,
{ItemId, _Retracted_Items,
_Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)}.
%%
-spec(max_items/2 ::
(
Max_Items :: undefined | non_neg_integer(),
New_ItemIds :: [ItemId::exmpp_pubsub:itemId()])
-> ItemIds :: {New_ItemIds::[ItemId::exmpp_pubsub:itemId()],
Old_ItemIds::[ItemId::exmpp_pubsub:itemId()]}
).
max_items(undefined = _Max_Items, New_ItemIds) ->
_ItemIds = {New_ItemIds, _Old_ItemIds = []};
max_items(0 = _Max_Items, New_ItemIds) ->
_ItemIds = {_New_ItemIds = [], _Old_ItemIds = New_ItemIds};
max_items(Max_Items, New_ItemIds) ->
_ItemIds = case Max_Items >= (Length_Items = length(New_ItemIds)) of
true ->
{New_ItemIds, _Old_ItemIds = []};
false ->
diff_items((Length_Items - Max_Items), _Count = 0, {New_ItemIds, []})
end.
%%
-spec(diff_items/3 ::
(
Diff_Items :: pos_integer(),
Count :: non_neg_integer(),
ItemIds :: {New_ItemIds::[ItemId::exmpp_pubsub:itemId()],
Old_ItemIds::[ItemId::exmpp_pubsub:itemId()]})
-> ItemIds :: {New_ItemIds::[ItemId::exmpp_pubsub:itemId()],
Old_ItemIds::[ItemId::exmpp_pubsub:itemId()]}
).
diff_items(Diff_Items, _Count = Diff_Items, ItemIds) ->
ItemIds;
diff_items(Diff_Items, Count, {[ItemId | New_ItemIds], Old_ItemIds}) ->
diff_items(Diff_Items, Count + 1, {New_ItemIds, [ItemId | Old_ItemIds]}).
%%
-spec(delete_old_items/6 ::
(
Suffix :: atom(),
Publisher :: xmpp_jid:usr_bare(),
NodeIdx :: exmpp_pubsub:nodeIdx(),
Node_Notify_Retract :: boolean(),
ItemIds :: [ItemId::exmpp_pubsub:itemId()],
%%
{Retracted_Items :: [Retracted_Item::{
ItemId :: exmpp_pubsub:itemId(),
Item_Options :: [] | pubsub_options:options_item()
}],
%
Publishers_Retracted_ItemIds :: {
%%
Entities_Retracted_ItemIds :: [Entity_Retracted_ItemIds::{
Entity :: xmpp_jid:usr_bare(),
ItemIds :: [ItemId::exmpp_pubsub:itemId()]
}],
%%
Publisher_Retracted_ItemIds :: [ItemId::exmpp_pubsub:itemId()]
}
})
-> {Retracted_Items :: [Retracted_Item::{
ItemId :: exmpp_pubsub:itemId(),
Item_Options :: [] | pubsub_options:options_item()
}],
Publisher_Retracted_ItemIds :: [ItemId::exmpp_pubsub:itemId()]}
).
delete_old_items(Suffix, _Publisher, NodeIdx, _Notify_Retract, [] = _ItemIds,
{Retracted_Items, {Entities_ItemIds, Publisher_ItemIds}}) ->
Table_Pubsub_State = table('pubsub_state', Suffix),
lists:foreach(fun
({Entity, Entity_ItemIds}) ->
case mnesia:read(Table_Pubsub_State, {Entity, NodeIdx}, write) of
[Pubsub_State] ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{
itemids = lists:foldl(fun
(Retracted_ItemId, ItemIds) ->
lists:delete(Retracted_ItemId, ItemIds)
end,
Pubsub_State#pubsub_state_dev.itemids,
Entity_ItemIds)
},
write);
[] -> %% shouldn't happen
ok
end
%
end, Entities_ItemIds),
{Retracted_Items, Publisher_ItemIds};
%%
delete_old_items(Suffix, Publisher, NodeIdx, Notify_Retract, [ItemId | ItemIds],
{Retracted_Items, Publishers_ItemIds}) ->
Table_Pubsub_Item = table('pubsub_item', Suffix),
delete_old_items(Suffix, Publisher, NodeIdx, Notify_Retract, ItemIds,
case mnesia:read(Table_Pubsub_Item, {ItemId, NodeIdx}, write) of
[Pubsub_Item] ->
mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write),
%% @TODO: Unregister 'pubsub#item_expire'
{_Retracted_Items = case
get_value(Pubsub_Item#pubsub_item_dev.options,
'notify_retract', Notify_Retract)
of
true ->
[{ItemId, Pubsub_Item#pubsub_item_dev.options}
| Retracted_Items];
false ->
Retracted_Items
end,
%%
_Publishers_ItemIds = lists:foldl(fun
%%
(Item_Owner, {Entities_ItemIds, Publisher_ItemIds})
when Item_Owner == Publisher ->
{Entities_ItemIds,
[ItemId | Publisher_ItemIds]};
%%
(_Item_Owner = Entity,
{Entities_ItemIds, Publisher_ItemIds}) ->
{_Entities_ItemIds = case
lists:keyfind(Entity, 1, Entities_ItemIds)
of
{_Entity, Entity_ItemIds} ->
lists:keyreplace(Entity, 1, Entities_ItemIds,
{Entity, [ItemId | Entity_ItemIds]});
false ->
[{Entity, [ItemId]} | Entities_ItemIds]
end,
Publisher_ItemIds}
end, Publishers_ItemIds, Pubsub_Item#pubsub_item_dev.owners)};
[] ->
{Retracted_Items, Publishers_ItemIds}
end).
%-- Retract_Item --%
-spec(retract_item/5 ::
(
Suffix :: atom(),
Pubsub_Node :: mod_pubsub_dev:pubsub_node(),
Pubsub_State :: mod_pubsub_dev:pubsub_state_owner()
| mod_pubsub_dev:pubsub_state_member()
| mod_pubsub_dev:pubsub_state_publish_only()
| mod_pubsub_dev:pubsub_state_publisher()
| mod_pubsub_dev:pubsub_state_none(),
ItemId :: exmpp_pubsub:itemId(),
Adhoc_Notify_Retract :: undefined | boolean())
-> {ok, undefined}
%
| {ok,
Item_Options :: [] | pubsub_options:options_item(),
Pubsub_States :: mod_pubsub_dev:pubsub_states()}
%%%
| {error, 'forbidden'}
| {error, 'item-not-found'}
).
retract_item(Suffix, Pubsub_Node,
#pubsub_state_dev{id = {Entity, NodeIdx}} = Pubsub_State, ItemId,
Adhoc_Notify_Retract) ->
Table_Pubsub_Item = table('pubsub_item', Suffix),
case mnesia:read(Table_Pubsub_Item, {ItemId, NodeIdx}, write) of
[Pubsub_Item]
when Pubsub_State#pubsub_state_dev.affiliation == 'owner'
orelse Pubsub_State#pubsub_state_dev.affiliation == 'publisher' ->
mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write),
Table_Pubsub_Last_Item = table('pubsub_last_item', Suffix),
case mnesia:read(Table_Pubsub_Last_Item, NodeIdx, read) of
[Pubsub_Last_Item]
when Pubsub_Last_Item#pubsub_last_item_dev.id == ItemId ->
mnesia:delete_object(Table_Pubsub_Last_Item,
Pubsub_Last_Item, write);
_ ->
ok
end,
Table_Pubsub_State = table('pubsub_state', Suffix),
case
retract_item(NodeIdx, ItemId, Table_Pubsub_State, Entity,
_Item_Owners = Pubsub_Item#pubsub_item_dev.owners, false)
of
true ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{
itemids = lists:delete(ItemId,
Pubsub_State#pubsub_state_dev.itemids)
},
write);
false ->
ok
end,
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{
itemids = lists:delete(ItemId,
Pubsub_Node#pubsub_node_dev.itemids)
},
write),
case
Adhoc_Notify_Retract == true
orelse
get_value(
{Pubsub_Node#pubsub_node_dev.options,
Pubsub_Item#pubsub_item_dev.options},
'notify_retract', false)
of
true ->
{ok,
_Item_Options = Pubsub_Item#pubsub_item_dev.options,
_Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)};
false ->
{ok, undefined}
end;
%%
[#pubsub_item_dev{creation = {_DateTime, _Creator = Entity}} = Pubsub_Item] ->
mnesia:delete_object(Table_Pubsub_Item, Pubsub_Item, write),
Table_Pubsub_Last_Item = table('pubsub_last_item', Suffix),
case mnesia:read(Table_Pubsub_Last_Item, NodeIdx, read) of
[Pubsub_Last_Item]
when Pubsub_Last_Item#pubsub_last_item_dev.id == ItemId ->
mnesia:delete_object(Table_Pubsub_Last_Item,
Pubsub_Last_Item, write);
_ ->
ok
end,
Table_Pubsub_State = table('pubsub_state', Suffix),
case
retract_item(NodeIdx, ItemId, Table_Pubsub_State, Entity,
_Item_Owners = Pubsub_Item#pubsub_item_dev.owners, false)
of
true ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{
itemids = lists:delete(ItemId,
Pubsub_State#pubsub_state_dev.itemids)
},
write);
false ->
ok
end,
mnesia:write(table('pubsub_node', Suffix),
Pubsub_Node#pubsub_node_dev{
itemids = lists:delete(ItemId,
Pubsub_Node#pubsub_node_dev.itemids)
},
write),
case
Adhoc_Notify_Retract == true
orelse
get_value(
{Pubsub_Node#pubsub_node_dev.options,
Pubsub_Item#pubsub_item_dev.options},
'notify_retract', false)
of
true ->
{ok,
_Item_Options = Pubsub_Item#pubsub_item_dev.options,
_Pubsub_States = mnesia:index_read(Table_Pubsub_State, NodeIdx, nodeidx)};
false ->
{ok, undefined}
end;
[_Pubsub_Item] ->
{error, 'forbidden'};
%%
[] ->
{error, 'item-not-found'}
end.
%%
-spec(retract_item/6 ::
(
NodeIdx :: exmpp_pubsub:nodeIdx(),
ItemId :: exmpp_pubsub:itemId(),
Table_Pubsub_State :: atom(),
Entity :: xmpp_jid:usr_bare() | undefined,
Item_Owners :: [Entity::xmpp_jid:usr_bare(),...],
Retract_ItemId :: boolean())
-> Retract_ItemId :: boolean()
).
retract_item(_NodeIdx, _ItemId, _Table_Pubsub_State, _Entity, [] = _Item_Owners,
Retract_ItemId) ->
Retract_ItemId;
%%
retract_item(NodeIdx, ItemId, Table_Pubsub_State, Entity,
[_Item_Owner = Entity | Item_Owners], _Retract_ItemId) ->
retract_item(NodeIdx, ItemId, Table_Pubsub_State, undefined, Item_Owners,
true);
%%
retract_item(NodeIdx, ItemId, Table_Pubsub_State, _Entity,
[_Item_Owner = Entity | Item_Owners], Retract_ItemId) ->
case mnesia:read(Table_Pubsub_State, {Entity, NodeIdx}, write) of
[Pubsub_State] ->
mnesia:write(Table_Pubsub_State,
Pubsub_State#pubsub_state_dev{
itemids = lists:delete(ItemId,
Pubsub_State#pubsub_state_dev.itemids)
},
write);
[] ->
ok
end,
retract_item(NodeIdx, ItemId, Table_Pubsub_State, _Entity, Item_Owners,
Retract_ItemId).
%-- Subscribe_Node --%
-spec(subscribe_node/8 ::
(
Suffix :: atom(),
Host :: xmpp_jid:raw_jid_component_bare(),
Node_Options :: pubsub_options:options_node(),
Node_Owners :: [Entity::xmpp_jid:usr_bare(),...],
Pubsub_State :: mod_pubsub_dev:pubsub_state(),
Resource :: undefined
| xmpp_jid:resource_jid()
| {'caps', xmpp_jid:resource_jid()},
Subscription_Options :: [] | pubsub_options:options_subscription(),
Pubsub_Features :: exmpp_pubsub:pubsub_features())
-> {result,
Subscription_Subscribed :: exmpp_pubsub:subscription_subscribed(),
Pubsub_Last_Item :: undefined | mod_pubsub_dev:pubsub_last_item()}
%
| {result,
Subscription_Pending :: exmpp_pubsub:subscription_pending(),
Pubsub_Last_Item :: undefined}
%%%
| {error, 'forbidden'}
| {error, 'not-authorized', 'presence-subscription-required'}
| {error, 'not-authorized', 'not-in-roster-group'}
| {error, 'not-authorized', 'pending-subscription'}
| {error, 'not-allowed', 'closed-node'}
).
subscribe_node(Suffix, Host, Node_Options, Node_Owners,
#pubsub_state_dev{id = {{_U,S,_R} = Entity, _NodeIdx}} = Pubsub_State, Resource,
Subscription_Options, Pubsub_Features) ->
Affiliation = Pubsub_State#pubsub_state_dev.affiliation,
Subscriptions = Pubsub_State#pubsub_state_dev.subscriptions,
case
options_on_subscribe_node(Host, Node_Options, Node_Owners, Entity,
Resource, Affiliation, Subscriptions, Subscription_Options,
Pubsub_Features)
of
%%
{ok, 'new',
{'pending', SubId, _Resource, _Subscription_Options} = Subscription} ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
affiliation = case Affiliation of
'none' -> 'member';
Affiliation -> Affiliation
end,
subscriptions = [Subscription | Subscriptions]
},
write),
Table_Pubsub_Subscription_Pending = table('pubsub_subscription_pending',
Suffix),
case
mnesia:read(Table_Pubsub_Subscription_Pending,
Pubsub_State#pubsub_state_dev.id, write)
of
[] ->
mnesia:write(Table_Pubsub_Subscription_Pending,
#pubsub_subscription_pending{
id = Pubsub_State#pubsub_state_dev.id,
nodeidx = Pubsub_State#pubsub_state_dev.nodeidx,
subids = [SubId]
},
write);
[Pubsub_Subscription_Pending] ->
mnesia:write(Table_Pubsub_Subscription_Pending,
Pubsub_Subscription_Pending#pubsub_subscription_pending{
subids = [SubId
| Pubsub_Subscription_Pending
#pubsub_subscription_pending.subids]
},
write)
end,
{result, Subscription, _Pubsub_Last_Item = undefined};
%%
{ok, Type, Subscription} ->
case Type of
'new' ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
affiliation = case Affiliation of
'none' -> 'member';
Affiliation -> Affiliation
end,
subscriptions = [Subscription | Subscriptions]
},
write);
'old' ->
ok
end,
{result,
Subscription,
_Pubsub_Last_Item = case
(get_value(Subscription_Options, 'deliver', true) == true)
andalso
(get_value(Subscription_Options, 'show-values') =/= [])
andalso
(get_value(Node_Options, 'send_last_published_item', 'never')
=/= 'never')
of
true ->
case
mnesia:read(table('pubsub_last_item', Suffix),
Pubsub_State#pubsub_state_dev.nodeidx,
read)
of
[] -> undefined;
[Pubsub_Last_Item] -> Pubsub_Last_Item
end;
false ->
undefined
end};
Error ->
Error
end.
%%
-spec(options_on_subscribe_node/9 ::
(
Host :: xmpp_jid:raw_jid_component_bare(),
Node_Options :: pubsub_options:options_node(),
Node_Owners :: [Entity::xmpp_jid:usr_bare(),...],
Entity :: xmpp_jid:usr_bare(),
Resource :: undefined
| xmpp_jid:resource_jid()
| {'caps', xmpp_jid:resource_jid()},
Affiliation :: exmpp_pubsub:affiliation(),
Subscriptions :: [] | exmpp_pubsub:subscriptions(),
Subscription_Options :: [] | pubsub_options:options_subscription(),
Pubsub_Features :: exmpp_pubsub:pubsub_features())
-> {ok,
Type :: 'new' | 'old',
Subscription :: exmpp_pubsub:subscription_subscribed()}
%
| {ok,
Type :: 'new',
Subscription :: exmpp_pubsub:subscription_pending()}
%%%
| {error, 'forbidden'}
| {error, 'not-authorized', 'presence-subscription-required'}
| {error, 'not-authorized', 'not-in-roster-group'}
| {error, 'not-authorized', 'pending-subscription'}
| {error, 'not-allowed', 'closed-node'}
).
options_on_subscribe_node(Host, Node_Options, Node_Owners, Entity,
Resource, Affiliation, Subscriptions, Subscription_Options, Pubsub_Features) ->
options_on_subscribe_node(get_option(Node_Options, 'subscribe'), Host,
Node_Options, Node_Owners, Entity, Resource, Affiliation, Subscriptions,
Subscription_Options,
_Multi_Subscribe = lists:member(<<"multi-subscribe">>, Pubsub_Features)).
%%
-spec(options_on_subscribe_node/10 ::
(
Option :: pubsub_options:option_node_access_model()
| pubsub_options:option_node_subscribe(),
Host :: xmpp_jid:raw_jid_component_bare(),
Node_Options :: pubsub_options:options_node(),
Node_Owners :: [Entity::xmpp_jid:usr_bare(),...],
Entity :: xmpp_jid:usr_bare(),
Resource :: undefined
| xmpp_jid:resource_jid()
| {'caps', xmpp_jid:resource_jid()},
Affiliation :: exmpp_pubsub:affiliation(),
Subscriptions :: [] | exmpp_pubsub:subscriptions(),
Subscription_Options :: [] | pubsub_options:options_subscription(),
Multi_Subscribe :: boolean())
-> {ok,
Type :: 'new' | 'old',
Subscription :: exmpp_pubsub:subscription_subscribed()}
%
| {ok,
Type :: 'new',
Subscription :: exmpp_pubsub:subscription_pending()}
%%%
| {error, 'forbidden'}
| {error, 'not-authorized', 'presence-subscription-required'}
| {error, 'not-authorized', 'not-in-roster-group'}
| {error, 'not-authorized', 'pending-subscription'}
| {error, 'not-allowed', 'closed-node'}
).
options_on_subscribe_node({'subscribe', Subscribe}, _Host, _Node_Options,
_Node_Owners, _Entity, _Resource, Affiliation, _Subscriptions,
_Subscription_Options, _Multi_Subscribe)
when Subscribe == false
orelse Affiliation == 'outcast'
orelse Affiliation == 'publish-only' ->
{error, 'forbidden'};
%%
options_on_subscribe_node({'subscribe', true}, Host, Node_Options,
Node_Owners, Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, Multi_Subscribe) ->
options_on_subscribe_node(get_option(Node_Options, 'access_model'), Host,
Node_Options, Node_Owners, Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, Multi_Subscribe);
options_on_subscribe_node({'access_model', open}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, _Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe) ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, Subscription} ->
{ok, 'old', Subscription};
false ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', open}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, _Affiliation, _Subscriptions,
Subscription_Options, true = _Multi_Subscribe) ->
{ok, 'new', exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', presence}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, Subscription} ->
{ok, 'old', Subscription};
false ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', presence}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
Subscription_Options, true = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', presence}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, Subscription} ->
{ok, 'old', Subscription};
false ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', presence}, Host, _Node_Options,
Node_Owners, Entity, Resource, _Affiliation, _Subscriptions,
Subscription_Options, _Multi_Subscribe) ->
case is_contact_subscribed_to_node_owners(Host, Entity, Node_Owners) of
false ->
{error, 'not-authorized', 'presence-subscription-required'};
_Node_Owner ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', roster}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
Subscription_Options, true = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', roster}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, Subscription} ->
{ok, 'old', Subscription};
false ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', roster}, _Host, Node_Options,
_Node_Owners, Entity, Resource, _Affiliation, _Subscriptions,
Subscription_Options, _Multi_Subscribe) ->
case
is_contact_in_allowed_roster_groups(Entity,
get_value(Node_Options, 'roster_groups_allowed', []))
of
false ->
{error, 'not-authorized', 'not-in-roster-group'};
{_Node_Owner, _Roster_Group} ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', authorize}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
Subscription_Options, true = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', authorize}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, Subscription} ->
{ok, 'old', Subscription};
false ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', authorize}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, _Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe) ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, _Subscription} ->
{error, 'not-authorized', 'pending-subscription'};
false ->
{ok,
'new',
exmpp_pubsub:subscription_pending(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', whitelist}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, _Subscriptions,
Subscription_Options, true = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)};
%%
options_on_subscribe_node({'access_model', whitelist}, _Host, _Node_Options,
_Node_Owners, _Entity, Resource, Affiliation, Subscriptions,
Subscription_Options, false = _Multi_Subscribe)
when Affiliation == 'owner'
orelse Affiliation == 'publisher'
orelse Affiliation == 'member' ->
case lists:keyfind(Resource, 3, Subscriptions) of
{_Resource, Subscription} ->
{ok, 'old', Subscription};
false ->
{ok,
'new',
exmpp_pubsub:subscription_subscribed(Resource, Subscription_Options)}
end;
%%
options_on_subscribe_node({'access_model', whitelist}, _Host, _Node_Options,
_Node_Owners, _Entity, _Resource, _Affiliation, _Subscriptions,
_Subscription_Options, _Multi_Subscribe) ->
{error, 'not-allowed', 'closed-node'}.
%-- Unsubscribe_Node --%
-spec(unsubscribe_node/6 ::
(
Suffix :: atom(),
Host :: xmpp_jid:raw_jid_component_bare(),
Node_Access_Model :: pubsub_options:access_model(),
Pubsub_State :: mod_pubsub_dev:pubsub_state_member()
| mod_pubsub_dev:pubsub_state_outcast()
| mod_pubsub_dev:pubsub_state_owner()
| mod_pubsub_dev:pubsub_state_publisher(),
Resource :: undefined
| xmpp_jid:resource_jid()
| {'caps', xmpp_jid:resource_jid()},
SubId :: undefined | exmpp_pubsub:subId())
-> {ok,
Resource :: undefined
| xmpp_jid:resource_jid()
| {'caps', xmpp_jid:resource_jid()},
SubId :: exmpp_pubsub:subId()}
%%%
| {error, 'unexpected', 'not-subscribed'}
| {error, 'not-acceptable', 'invalid-subid'}
| {error, 'bad-request', 'subid-required'}
| {error, 'not-acceptable', 'invalid-subid'}
).
unsubscribe_node(Suffix, Host, Node_Access_Model,
#pubsub_state_dev{subscriptions = [{Subscription_State, SubId, Resource, _}]}
= Pubsub_State, Resource, _SubId)
when _SubId == undefined orelse _SubId == SubId ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
subscriptions = []
},
write),
%% unregister pending subscription
case Subscription_State of
'pending' ->
unregister_pending_subscription(Suffix,
Pubsub_State#pubsub_state_dev.id, SubId);
_ ->
ok
end,
case Node_Access_Model of
'roster' ->
ok;
_ ->
ok
end,
{ok, Resource, SubId};
%%
unsubscribe_node(Suffix, Host, Node_Access_Model,
#pubsub_state_dev{subscriptions = [{_Subscription_State, SubId, _Resource, _}]}
= Pubsub_State, Resource, SubId) ->
{error, 'unexpected', 'not-subscribed'};
%%
unsubscribe_node(Suffix, Host, Node_Access_Model,
#pubsub_state_dev{subscriptions = [{_Subscription_State, _SubId, Resource, _}]}
= Pubsub_State, Resource, SubId) ->
{error, 'not-acceptable', 'invalid-subid'};
%%
unsubscribe_node(Suffix, Host, Node_Access_Model, Pubsub_State, Resource,
undefined = _SubId) ->
case lists:keytake(Resource, 3, Pubsub_State#pubsub_state_dev.subscriptions) of
{value,
{Subscription_State, SubId, Resource, _} = Subscription, Subscriptions} ->
case lists:keymember(Resource, 3, Subscriptions) of
false ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
subscriptions = Subscriptions
},
write),
%% unregister pending subscription
case Subscription_State of
'pending' ->
unregister_pending_subscription(Suffix,
Pubsub_State#pubsub_state_dev.id, SubId);
_ ->
ok
end,
case Node_Access_Model of
'roster' ->
ok;
_ ->
ok
end,
%% TODO : unregister 'pubsub#tempsub'
{ok, Resource, SubId};
true ->
{error, 'bad-request', 'subid-required'}
end;
false ->
{error, 'unexpected', 'not-subscribed'}
end;
%%
unsubscribe_node(Suffix, Host, Node_Access_Model, Pubsub_State, Resource, SubId) ->
case lists:keytake(SubId, 2, Pubsub_State#pubsub_state_dev.subscriptions) of
{value,
{Subscription_State, SubId, Resource, _} = Subscription, Subscriptions} ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
subscriptions = Subscriptions
},
write),
%% unregister pending subscription
case Subscription_State of
'pending' ->
unregister_pending_subscription(Suffix,
Pubsub_State#pubsub_state_dev.id, SubId);
_ ->
ok
end,
case Node_Access_Model of
'roster' ->
ok;
_ ->
ok
end,
{ok, Resource, SubId};
{value, {_Subscription_State, SubId, _Resource, _} = Subscription, _} ->
{error, 'unexpected', 'not-subscribed'};
false ->
{error, 'not-acceptable', 'invalid-subid'}
end.
%%
-spec(register_pending_subscription/3 ::
(
Suffix :: atom(),
StateId :: {Entity::xmpp_jid:usr_bare(), NodeIdx::exmpp_pubsub:nodeIdx()},
SubId :: exmpp_pubsub:subId())
-> 'ok'
).
register_pending_subscription(Suffix, {Entity, NodeIdx} = _StateId, SubId) ->
Table_Pubsub_Subscription_Pending = table('pubsub_subscription_pending', Suffix),
case mnesia:read(Table_Pubsub_Subscription_Pending, {Entity, NodeIdx}, write) of
[] ->
mnesia:write(Table_Pubsub_Subscription_Pending,
#pubsub_subscription_pending{
id = {Entity, NodeIdx},
nodeidx = NodeIdx,
subids = [SubId]
},
write);
[Pubsub_Subscription_Pending] ->
mnesia:write(Table_Pubsub_Subscription_Pending,
Pubsub_Subscription_Pending#pubsub_subscription_pending{
subids = [SubId
| Pubsub_Subscription_Pending
#pubsub_subscription_pending.subids]
},
write)
end.
%%
-spec(unregister_pending_subscription/3 ::
(
Suffix :: atom(),
StateId :: {Entity::xmpp_jid:usr_bare(), NodeIdx::exmpp_pubsub:nodeIdx()},
SubId :: exmpp_pubsub:subId())
-> 'ok'
).
unregister_pending_subscription(Suffix, StateId, SubId) ->
Table_Pubsub_Subscription_Pending = table('pubsub_subscription_pending', Suffix),
case mnesia:read(Table_Pubsub_Subscription_Pending, StateId, write) of
%%
[#pubsub_subscription_pending{subids = [SubId]} = Pubsub_Subscription_Pending] ->
mnesia:delete_object(Table_Pubsub_Subscription_Pending,
Pubsub_Subscription_Pending, write);
%%
[Pubsub_Subscription_Pending] ->
mnesia:write(Table_Pubsub_Subscription_Pending,
Pubsub_Subscription_Pending#pubsub_subscription_pending{
subids = lists:delete(SubId,
Pubsub_Subscription_Pending#pubsub_subscription_pending.subids)
},
write);
[] ->
ok
end.
%-- Set_Configure_Subscription --%
-spec(set_configure_subscription/5 ::
(
Suffix :: atom(),
Pubsub_State :: mod_pubsub_dev:pubsub_state_member()
| mod_pubsub_dev:pubsub_state_owner()
| mod_pubsub_dev:pubsub_state_publisher(),
SubId :: undefined | exmpp_pubsub:subId(),
Resource :: undefined
| xmpp_jid:resource_jid()
| {'caps', xmpp_jid:resource_jid()},
Subscription_Options :: pubsub_options:options_subscription())
-> 'ok'
%%%
| {error, 'unexpected-request', 'not-subscribed'}
| {error, 'bad-request', 'subid-required'}
| {error, 'forbidden'}
| {error, 'not-acceptable', 'invalid-subid'}
).
set_configure_subscription(Suffix, Pubsub_State, undefined = _SubId, Resource,
Subscription_Options) ->
case
lists:keytake(Resource, 3, Pubsub_State#pubsub_state_dev.subscriptions)
of
{value, {Subscription_State, SubId, Resource, _Subscription_Options},
Subscriptions} ->
case lists:keymember(Resource, 3, Subscriptions) of
false
when Subscription_State == 'pending' ->
{error, 'forbidden'};
false ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
subscriptions = [
{Subscription_State, SubId, Resource,
Subscription_Options}
| Subscriptions]
},
write),
'ok';
true ->
{error, 'bad-request', 'subid-required'}
end;
false ->
{error, 'unexpected-request', 'not-subscribed'}
end;
%%
set_configure_subscription(Suffix, Pubsub_State, SubId, Resource,
Subscription_Options) ->
case lists:keytake(SubId, 2, Pubsub_State#pubsub_state_dev.subscriptions) of
{value, {'pending', SubId, Resource, _Subscription_Options},
_Subscriptions} ->
{error, 'forbidden'};
{value, {Subscription_State, SubId, Resource, _Subscription_Options},
Subscriptions} ->
mnesia:write(table('pubsub_state', Suffix),
Pubsub_State#pubsub_state_dev{
subscriptions = [
{Subscription_State, SubId, Resource,
Subscription_Options}
| Subscriptions]
},
write),
'ok';
{value, {_Subscription_State, SubId, _Resource, _Subscription_Options},
_Subscriptions} ->
{error, 'unexpected-request', 'not-subscribed'};
false ->
case
lists:keytake(Resource, 3,
Pubsub_State#pubsub_state_dev.subscriptions)
of
{value, {'pending', _SubId, Resource, _Subscription_Options},
_Subscriptions} ->
{error, 'forbidden'};
{value, {_Subscription_State, _SubId, _Resource, _Subscription_Options},
_Subscriptions} ->
{error, 'not-acceptable', 'invalid-subid'};
false ->
{error, 'unexpected-request', 'not-subscribed'}
end
end.
%-- Get_Items --%
-spec(get_items/5 ::
(
Suffix :: pubsub_db_mnesia:table(),
Host :: xmpp_jid:raw_jid_component_bare(),
Node_Parameters :: {NodeIdx :: exmpp_pubsub:nodeIdx(),
Node_Owners :: mod_pubsub_dev:node_owners(),
Node_ItemIds :: [] | exmpp_pubsub:itemIds(),
Node_Access_Model :: pubsub_options:access_model(),
Node_Groups :: pubsub_options:rosters_groups_allowed()},
%%
Entity_Parameters :: {Entity :: xmpp_jid:usr_bare(),
Affiliation :: exmpp_pubsub:affiliation(),
Access :: undefined | 'pending' | 'roster' | 'presence' | 'authorize'},
%%
Criteria :: {Max_Items :: non_neg_integer(),
ItemIds :: undefined,
_SubId :: exmpp_pubsub:subId()}
| {Max_Items :: undefined,
ItemIds :: exmpp_pubsub:itemIds(),
_SubId :: exmpp_pubsub:subId()})
-> {ok,
Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items(),
Cache :: {Presence_Cache :: undefined,
Groups_Cache :: undefined}}
%
| {ok,
Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items(),
Cache :: {Presence_Cache :: true,
Groups_Cache :: undefined}}
%
| {ok,
Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items(),
Cache :: {Presence_Cache :: undefined,
Groups_Cache :: [{Node_Owner :: xmpp_jid:usr_bare(),
Groups :: [Group::binary()]}]}}
%%%
| {error, 'forbidden'}
| {error, 'not-authorized', 'presence-subscription-required'}
| {error, 'not-authorized', 'not-in-roster-group'}
| {error, 'not-allowed', 'closed-node'}
).
get_items(_Suffix, _Host, _Node_Parameters, {_Entity, Affiliation, Access}, _Criteria)
when Affiliation == 'outcast'
orelse Affiliation == 'publish-only'
orelse Access == 'pending' ->
{error, 'forbidden'};
%%
get_items(Suffix, _Host,
{NodeIdx, _Node_Owners, Node_ItemIds, Node_Access_Model, _Node_Groups},
{_Entity, Affiliation, Access}, {Max_Items, ItemIds, _SubId})
when Affiliation == 'owner'
%
orelse Affiliation == 'publisher'
%
orelse Affiliation == 'member'
%
orelse Node_Access_Model == 'open'
%
orelse (Node_Access_Model == 'presence'
andalso
Access == 'presence'
orelse Access == 'roster')
%
orelse (Node_Access_Model == 'roster'
andalso
Access == 'roster')
%
orelse (Node_Access_Model == 'authorize'
andalso
Access == 'authorize') ->
{ok,
_Pusbub_Items = get_items(Suffix, NodeIdx,
get_max_itemids(Max_Items, ItemIds, Node_ItemIds)),
_Cache = {undefined, undefined}};
%
get_items(Suffix, Host,
{NodeIdx, Node_Owners, Node_ItemIds, 'presence' = _Node_Access_Model, _Node_Groups},
{Entity, _Affiliation, _Access}, {Max_Items, ItemIds, _SubId}) ->
case is_contact_subscribed_to_node_owners(Host, Entity, Node_Owners) of
false ->
{error, 'not-authorized', 'presence-subscription-required'};
Node_Owner ->
{ok,
_Pusbub_Items = get_items(Suffix, NodeIdx,
get_max_itemids(Max_Items, ItemIds, Node_ItemIds)),
_Cache = {_Presence_Cache = true, _Groups_Cache = undefined}}
end;
%%
get_items(Suffix, _Host,
{NodeIdx, _Node_Owners, Node_ItemIds, 'roster' = _Node_Access_Model, Node_Groups},
{Entity, _Affiliation, _Access}, {Max_Items, ItemIds, _SubId}) ->
case is_contact_in_allowed_roster_groups(Entity, Node_Groups) of
{Node_Owner, Roster_Group} ->
{ok,
_Pusbub_Items = get_items(Suffix, NodeIdx,
get_max_itemids(Max_Items, ItemIds, Node_ItemIds)),
_Cache = {
_Presence_Cache = undefined,
_Groups_Cache = [{Node_Owner, [Roster_Group]}]
}
};
false ->
{error, 'not-authorized', 'not-in-roster-group'}
end;
%%
get_items(_Suffix, _Host,
{_NodeIdx, _Node_Owners, _Node_ItemIds, 'authorize' = _Node_Access_Model, _Node_Groups},
_Entity_Parameters, _Criteria) ->
{error, 'not-allowed', 'closed-node'};
%%
get_items(_Suffix, _Host, _Node_Parameters, _Entity_Parameters, _Criteria) ->
{error, 'forbidden'}.
%%
-spec(get_max_itemids/3 ::
(
Max_Items :: undefined | non_neg_integer(),
ItemIds :: [] | exmpp_pubsub:itemIds(),
Node_ItemIds :: [] | exmpp_pubsub:itemIds())
-> Max_ItemIds :: undefined | [] | exmpp_pubsub:itemIds()
).
get_max_itemids(undefined = _Max_Items, [] = _ItemIds, _Node_ItemIds) ->
_Max_ItemIds = undefined;
%%
get_max_itemids(undefined = _Max_Items, ItemIds, Node_ItemIds) ->
_Max_ItemIds = lists:filter(fun
(ItemId) ->
lists:member(ItemId, Node_ItemIds)
end, ItemIds);
%%
get_max_itemids(Max_Items, undefined = _ItemIds, Node_ItemIds) ->
_Max_ItemIds = get_max_itemids(Max_Items, [], Node_ItemIds);
%%
get_max_itemids(_Max_Items, ItemIds, _Node_ItemIds)
when _Max_Items == 0 orelse _Node_ItemIds == [] ->
_Max_ItemIds = lists:reverse(ItemIds);
%%
get_max_itemids(Max_Items, ItemIds, [ItemId | Node_ItemIds]) ->
get_max_itemids(Max_Items - 1, [ItemId | ItemIds], Node_ItemIds).
%%
-spec(get_items/3 ::
(
Suffix :: pubsub_db_mnesia:suffix(),
NodeIdx :: exmpp_pubsub:nodeIdx(),
ItemIds :: undefined | [] | exmpp_pubsub:itemIds())
-> Pubsub_Items :: [] | mod_pubsub_dev:pubsub_items()
).
get_items(Suffix, NodeIdx, undefined = _ItemIds) ->
_Pubsub_Items = mnesia:index_read(table('pubsub_item', Suffix), NodeIdx, nodeidx);
%%
get_items(Suffix, NodeIdx, ItemIds) ->
Table_Pubsub_Item = table('pubsub_item', Suffix),
_Pubsub_Items = lists:foldl(fun
(ItemId, Pubsub_Items) ->
case
mnesia:index_match_object(Table_Pubsub_Item,
#pubsub_item_dev{
id = {ItemId, NodeIdx},
nodeidx = NodeIdx,
_ = '_'
},
nodeidx,
read)
of
[Pubsub_Item] -> [Pubsub_Item | Pubsub_Items];
_ -> Pubsub_Items
end
end, [], ItemIds).