path: root/src/mod_pubsub_ng/pubsub_hooks.erl

%%% ====================================================================
%%% ``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-2011, ProcessOne
%%% All Rights Reserved.''
%%% This software is copyright 2006-2011, ProcessOne.
%%%
%%% @copyright 2006-2011 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_hooks).
-author('karim.gemayel@process-one.net').

-compile(export_all).

-include("pubsub_dev.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
]).

-import(pubsub_db_mnesia,
[
  table/2
]).

%% 'node_config#send_last_published_item'
-spec(presence_online/3 ::
(
  From   :: xmpp_jid:entity_full(),
  To     :: xmpp_jid:entity_full(),
  C2SPid :: pid())
    -> 'ok'
).

presence_online(#jid{luser = U, lserver = S, lresource = R} = Jid, Jid, C2SPid) ->
    ?INFO_MSG("PRESENCE ONLINE From ~p ~n, To ~p ~n, C2SPid ~p ~n",
        [Jid, Jid, C2SPid]),
    Pubsub_Features = node_flat_dev:pubsub_features(),
    case lists:member(<<"last-published">>, Pubsub_Features) of
        true ->
            spawn(?MODULE, last_published_items,
                [_Host = <<"localhost">>, {U,S,R}]);
        false ->
            ok
    end;
%%
presence_online(_, _, _) ->
    ok.


%%
-spec(last_published_items/2 ::
(
  Host   :: xmpp_jid:raw_jid_component_bare(),
  Entity :: xmpp_jid:usr_full())
    -> 'ok'
).

last_published_items(Host, {U,S,_R} = Entity) ->
    Table_Pubsub_State = table('pubsub_state', 'dev'),
    Table_Pubsub_Node = table('pubsub_node', 'dev'),
    Table_Pubsub_Last_Item = table('pubsub_last_item', 'dev'),
    lists:foreach(fun
        (State) ->
            last_published_items(Host, Entity, Table_Pubsub_Node,
                Table_Pubsub_Last_Item, State)
    end,
        mnesia:dirty_select(Table_Pubsub_State,
            [{#pubsub_state_dev{
                  id            = {{U,S,undefined}, '$1'},
                  affiliation   = '$2',
                  access        = '$3',
                  subscriptions = '$4',
                  _             = '_'
             },
             [{'=/=', '$2', 'outcast'},
              {'=/=', '$3', 'pending'},
              {'=/=', '$4', []}],
             ['$$']}])).

%%
-spec(last_published_items/5 ::
(
  Host              :: xmpp_jid:raw_jid_component_bare(),
  Entity            :: xmpp_jid:usr_full(),
  Table_Pubsub_Node :: atom(),
  Table_Pubsub_Last_Item :: atom(),
  State                  :: [exmpp_pubsub:nodeIdx()           |
                             'member' | 'owner' | 'publisher' |
                             _                                |
                             exmpp_pubsub:subscriptions(),... ])
    -> 'ok'
).

last_published_items(Host, {_, _, Online_Resource} = Entity,
  Table_Pubsub_Node, Table_Pubsub_Last_Item,
  [NodeIdx, Affiliation, _Access, Subscriptions]) ->
    case mnesia:dirty_index_read(Table_Pubsub_Node, NodeIdx, idx) of
        [#pubsub_node_dev{
             id      = {Pubsub_Host, NodeId},
             owners  = Node_Owners,
             options = Node_Options
         }] ->
            case get_value(Node_Options, 'send_last_published_item') of
                'on_sub_and_presence' ->
                    case mnesia:dirty_read(Table_Pubsub_Last_Item, NodeIdx) of
                        [#pubsub_last_item_dev{
                             id       = ItemId,
                             creation = {DateTime, Publisher},
                             payload  = Payload,
                             options  = Item_Options
                         }] ->
                            spawn(pubsub_broadcast, broadcast_publish_last2,
                                [Host, Pubsub_Host, NodeId, Node_Options,
                                 Node_Owners,
                                 [{ItemId, Item_Options, Payload, Publisher, DateTime}],
                                   Entity, Affiliation,
                                 lists:foldl(fun
                                    ({Subscription_State, SubId, Resource, Subscription_Options},
                                     Acc)
                                      when    Subscription_State =/= 'pending'
                                      andalso (Resource == undefined
                                                 orelse
                                               Resource == Online_Resource) ->
                                        [{Subscription_State, SubId,
                                          Online_Resource, Subscription_Options}
                                        | Acc];
                                    (_Subscription, Acc) ->
                                        Acc
                                    end, [], Subscriptions)]);
                        _ ->
                            ok
                    end;
                _ ->
                    ok
            end;
        _ ->
            ok
    end.

%% 'node_config#purge_offline'
%% 'node_config#tempsub'
%% 'subscribe_options#expire'

-spec(presence_offline/3 ::
(
  _   :: _,
  Jid :: xmpp_jid:entity_full(),
  _   :: _)
    -> 'ok'
).

presence_offline({_DateTime, _Pid},
  #jid{luser = U, lserver = S, lresource = Offline_Resource} = _Jid, _) ->
    Host = <<"localhost">>,
    Pubsub_Features = node_flat_dev:pubsub_features(),
    Subscribe = lists:member(<<"subscribe">>, Pubsub_Features),
    Leased_Subscription = lists:member(<<"leased-subscription">>, Pubsub_Features),
    Purge_Nodes = lists:member(<<"purge-nodes">>, Pubsub_Features),
    Persistent_Items = lists:member(<<"persistent-items">>, Pubsub_Features),
    Subscription_Notifications = lists:member(<<"subscription-notifications">>,
        Pubsub_Features),
    Table_Pubsub_State = table('pubsub_state', 'dev'),
    Table_Pubsub_Node = table('pubsub_node', 'dev'),
    Online_Resources = case ejabberd_sm:get_user_resources(U, S) of
        [] -> false;
        _  -> true
    end,
    lists:foreach(fun
        (Pubsub_State) ->
            presence_offline(Host,
                _Entity = {U,S,undefined},
                Table_Pubsub_State,
                Pubsub_State,
                Table_Pubsub_Node,
                Offline_Resource,
                Online_Resources,
                {Subscribe,
                 Leased_Subscription,
                 Purge_Nodes,
                 Persistent_Items,
                 Subscription_Notifications})
    end,
        mnesia:dirty_match_object(Table_Pubsub_State,
            #pubsub_state_dev{
                id = {{U,S,undefined}, '_'},
                _  = '_'
            })).

%%
-spec(presence_offline/8 ::
(
  Host               :: xmpp_jid:raw_jid_component_bare(),
  Entity             :: xmpp_jid:usr_bare(),
  Table_Pubsub_State :: atom(),
  Pubsub_State       :: mod_pubsub_dev:pubsub_state(),
  Table_Pubsub_Node  :: atom(),
  Offline_Resource   :: xmpp_jid:resource_jid(),
  Online_Resources   :: boolean(),
  Pubsub_Features    :: {Subscribe                  :: boolean(),
                         Leased_Subscription        :: boolean(),
                         Purge_Nodes                :: boolean(),
                         Persistent_Items           :: boolean(),
                         Subscription_Notifications :: boolean()})
    -> 'ok'
).

presence_offline(Host, Entity, Table_Pubsub_State, Pubsub_State,
  Table_Pubsub_Node, Offline_Resource, Online_Resources,
  {Subscribe, Leased_Subscription, Purge_Nodes, Persistent_Items,
   Subscription_Notifications}) ->
    case
        mnesia:dirty_index_read(Table_Pubsub_Node,
            Pubsub_State#pubsub_state_dev.nodeidx, idx)
    of
        [#pubsub_node_dev{id = {Pubsub_Host, NodeId}} = Pubsub_Node] ->
            Node_Options = Pubsub_Node#pubsub_node_dev.options,

            case
                Subscribe == true
                    andalso
                get_value(Node_Options, 'tempsub') == true
            of
                true ->
                    case
                        filter_tempsub_subscriptions(
                            get_value(Node_Options, 'notify_sub'),
                            Pubsub_State#pubsub_state_dev.subscriptions,
                            Offline_Resource, Online_Resources, {[], []})
                    of
                        %%
                        {_Unexpired_Subscriptions, [] = _Expired_Subscriptions} ->
                            ok;
                        %%
                        {[] = _Unexpired_Subscriptions, Expired_Subscriptions}
                          when    Pubsub_State#pubsub_state_dev.affiliation == 'member'
                          andalso Pubsub_State#pubsub_state_dev.itemids     == [] ->
                            mnesia:dirty_delete_object(Table_Pubsub_State,
                                Pubsub_State),
                            Notification_Type = get_value(Node_Options,
                                'notification_type', 'headline'),
                            notify_subscriptions(Host, Pubsub_Host,
                                Entity, NodeId, Notification_Type,
                                _Recipients = case Subscription_Notifications of
                                    true ->
                                        case
                                            lists:member(Entity,
                                                Pubsub_Node#pubsub_node_dev.owners)
                                        of
                                            true ->
                                                Pubsub_Node#pubsub_node_dev.owners;
                                            false ->
                                                [Entity
                                                | Pubsub_Node#pubsub_node_dev.owners]
                                        end;
                                    false ->
                                        Pubsub_Node#pubsub_node_dev.owners
                                end,
                                Expired_Subscriptions),
                            ok;
                        %%
                        {Unexpired_Subscriptions, Expired_Subscriptions} ->
                            mnesia:dirty_write(Table_Pubsub_State,
                                Pubsub_State#pubsub_state_dev{
                                    subscriptions = Unexpired_Subscriptions
                                }),
                            Notification_Type = get_value(Node_Options,
                                'notification_type', 'headline'),
                                notify_subscriptions(Host, Pubsub_Host,
                                Entity, NodeId, Notification_Type,
                                _Recipients = case Subscription_Notifications of
                                    true ->
                                        case
                                            lists:member(Entity,
                                                Pubsub_Node#pubsub_node_dev.owners)
                                        of
                                            true ->
                                                Pubsub_Node#pubsub_node_dev.owners;
                                            false ->
                                                [Entity
                                                | Pubsub_Node#pubsub_node_dev.owners]
                                        end;
                                    false ->
                                        Pubsub_Node#pubsub_node_dev.owners
                                end,
                                Expired_Subscriptions),
                            ok
                    end;
                _ ->
                    case Subscribe == true andalso Leased_Subscription == true of
                        true ->
                            case
                                filter_expired_subscriptions(
                                    get_value(Node_Options, 'notify_sub'),
                                    Pubsub_State#pubsub_state_dev.subscriptions,
                                    Offline_Resource, Online_Resources, {[], []})
                            of
                        %%
                                {_Unexpired_Subscriptions, [] = _Expired_Subscriptions} ->
                                    ok;
                                %%
                                {[] = _Unexpired_Subscriptions, Expired_Subscriptions}
                                  when Pubsub_State#pubsub_state_dev.affiliation == 'member' ->
                                    mnesia:dirty_delete_object(Table_Pubsub_State,
                                        Pubsub_State),
                                    Notification_Type = get_value(Node_Options,
                                        'notification_type', 'headline'),
                                    notify_subscriptions(Host, Pubsub_Host,
                                        Entity, NodeId, Notification_Type,
                                        _Recipients = case
                                            Subscription_Notifications
                                        of
                                            true ->
                                                case
                                                    lists:member(Entity,
                                                    Pubsub_Node#pubsub_node_dev.owners)
                                                of
                                                    true ->
                                                        Pubsub_Node#pubsub_node_dev.owners;
                                                    false ->
                                                        [Entity
                                                        |Pubsub_Node#pubsub_node_dev.owners]
                                                end;
                                            false ->
                                                Pubsub_Node#pubsub_node_dev.owners
                                        end,
                                        Expired_Subscriptions),
                                    ok;
                                %%
                                {Unexpired_Subscriptions, Expired_Subscriptions} ->
                                    mnesia:dirty_write(Table_Pubsub_State,
                                        Pubsub_State#pubsub_state_dev{
                                            subscriptions = Unexpired_Subscriptions
                                        }),
                                    Notification_Type = get_value(Node_Options,
                                        'notification_type', 'headline'),
                                    notify_subscriptions(Host, Pubsub_Host,
                                        Entity, NodeId, Notification_Type,
                                        _Recipients = case
                                            Subscription_Notifications
                                        of
                                            true ->
                                                case
                                                    lists:member(Entity,
                                                    Pubsub_Node#pubsub_node_dev.owners)
                                                of
                                                    true ->
                                                        Pubsub_Node#pubsub_node_dev.owners;
                                                    false ->
                                                        [Entity
                                                        | Pubsub_Node#pubsub_node_dev.owners]
                                                end;
                                            false ->
                                                Pubsub_Node#pubsub_node_dev.owners
                                        end,
                                        Expired_Subscriptions),
                                    ok
                            end;
                        false ->
                            ok
                    end
            end;
        [] ->
            ok
    end.

%%
-spec(notify_subscriptions/7 ::
(
  Host              :: xmpp_jid:raw_jid_component_bare(),
  Pubsub_Host       :: exmpp_pubsub:host(),
  Entity            :: xmpp_jid:usr_bare(),
  NodeId            :: exmpp_pubsub:nodeId(),
  Notification_Type :: 'message' | 'headline',
  Recipients        :: [Entity::xmpp_jid:usr_bare(),...],
  Subscriptions     :: [Subscription::exmpp_pubsub:subscription(),...])
    -> 'ok'
).

notify_subscriptions(Host, Pubsub_Host, {U,S,_} = _Entity, NodeId,
  Notification_Type, Recipients, Subscriptions) ->
    Pubsub_Component_Jid = jlib:make_jid(<<>>, Pubsub_Host, <<>>),
    Jids = [pubsub_tools:make_jid(Recipient) || Recipient <- Recipients],
    lists:foreach(fun
        ({_, SubId, Resource, _}) ->
            Subscriber = jlib:jid_to_string({U,S,Resource}),
            lists:foreach(fun
                (Recipient) ->
                    spawn(pubsub_broadcast, notify_subscription,
                        [Host, NodeId, Pubsub_Component_Jid, Recipient,
                         Notification_Type, {Subscriber, 'none', SubId}])
            end, Jids)
    end, Subscriptions).

%%
filter_purged_offline_itemids([Publisher_ItemId | Publisher_ItemIds],
  Table_Pubsub_Item, NodeIdx, {U,S,R} = _Entity,
  {Node_ItemIds, Unpurged_ItemIds, Purged_ItemIds}) ->
    filter_purged_offline_itemids(Publisher_ItemIds, Table_Pubsub_Item, NodeIdx,
        {U,S,R},
        case
            mnesia:dirty_index_match_object(Table_Pubsub_Item,
                #pubsub_item_dev{
                    id      = {Publisher_ItemId, NodeIdx},
                    nodeidx = NodeIdx,
                    _       = '_'
                },
                nodeidx)
        of
            [#pubsub_item_dev{creation = {_DateTime, {U,S,_}}} = Pubsub_Item] ->
                mnesia:dirty_delete_object(Table_Pubsub_Item, Pubsub_Item);
            _ ->
                {Node_ItemIds,
                 [Publisher_ItemId | Unpurged_ItemIds],
                 Purged_ItemIds}
        end).


%%
-spec(filter_tempsub_subscriptions/5 ::
(
  Notify_Sub                     :: boolean() | 'none',
  Subscriptions                  :: [] | exmpp_pubsub:subscriptions(),
  Offline_Resource               :: xmpp_jid:resource_jid(),
  Online_Resources               :: boolean(),
  Filtered_TempSub_Subscriptions :: {
      Unexpired_Subscriptions :: [] | exmpp_pubsub:subscriptions(),
      Expired_Subscriptions   :: [] | exmpp_pubsub:subscriptions()
  })
    -> Filtered_TempSub_Subscriptions :: {
           Unexpired_Subscriptions :: [] | exmpp_pubsub:subscriptions(),
           Expired_Subscriptions   :: [] | exmpp_pubsub:subscriptions()
       }
).

filter_tempsub_subscriptions(_Notify_Sub, [] = _Subscriptions,
  _Offline_Resource, _Online_Resources, Filtered_TempSub_Subscriptions) ->
    Filtered_TempSub_Subscriptions;
%%
filter_tempsub_subscriptions(Notify_Sub,
  [{Subscription_State, SubId, Resource, Subscription_Options} | Subscriptions],
  Offline_Resource, Online_Resources,
  {Unexpired_Subscriptions, Expired_Subscriptions})
  when ((Online_Resources == false
             andalso
        (Resource == undefined orelse Resource == Offline_Resource))
  orelse
        (Online_Resources == true
             andalso
         Resource == Offline_Resource)) ->
    filter_tempsub_subscriptions(Notify_Sub, Subscriptions, Offline_Resource,
        Online_Resources,
        {Unexpired_Subscriptions,
         _Expired_Subscriptions = case Notify_Sub of
             true ->
                [{Subscription_State, SubId, Resource, Subscription_Options}
                | Expired_Subscriptions];
             _ ->
                Expired_Subscriptions
         end});
%%
filter_tempsub_subscriptions(Notify_Sub, [Subscription | Subscriptions],
  Offline_Resource, Online_Resources,
  {Unexpired_Subscriptions, Expired_Subscriptions}) ->
    filter_tempsub_subscriptions(Notify_Sub, Subscriptions, Offline_Resource,
        Online_Resources,
        {[Subscription | Unexpired_Subscriptions], Expired_Subscriptions}).

%%
-spec(filter_expired_subscriptions/5 ::
(
  Notify_Sub                     :: boolean() | 'none',
  Subscriptions                  :: [] | exmpp_pubsub:subscriptions(),
  Offline_Resource               :: xmpp_jid:resource_jid(),
  Online_Resources               :: boolean(),
  Filtered_Expired_Subscriptions :: {
      Unexpired_Subscriptions :: [] | exmpp_pubsub:subscriptions(),
      Expired_Subscriptions   :: [] | exmpp_pubsub:subscriptions()
  })
    -> Filtered_Expired_Subscriptions :: {
           Unexpired_Subscriptions :: [] | exmpp_pubsub:subscriptions(),
           Expired_Subscriptions   :: [] | exmpp_pubsub:subscriptions()
       }
).

filter_expired_subscriptions(_Notify_Sub, [] = _Subscriptions, _Offline_Resource,
  _Online_Resources, Filtered_Expired_Subscriptions) ->
    Filtered_Expired_Subscriptions;
%%
filter_expired_subscriptions(Notify_Sub,
  [{Subscription_State, SubId, Resource, Subscription_Options} | Subscriptions],
  Offline_Resource, Online_Resources,
  {Unexpired_Subscriptions, Expired_Subscriptions})
  when    Subscription_Options =/= []
  andalso ((Online_Resources == false
                andalso
           (Resource == undefined orelse Resource == Offline_Resource))
                        orelse
           (Online_Resources == true
                 andalso
            Resource == Offline_Resource)) ->
    filter_expired_subscriptions(Notify_Sub, Subscriptions, Offline_Resource,
        Online_Resources,
        case get_value(Subscription_Options, 'expire') of
            'presence' ->
                {Unexpired_Subscriptions,
                 _Expired_Subscriptions = case Notify_Sub of
                    true ->
                        [{Subscription_State, SubId, Resource, Subscription_Options}
                        | Expired_Subscriptions];
                    false ->
                        Expired_Subscriptions
                 end};
            _ ->
                {[{Subscription_State, SubId, Resource, Subscription_Options}
                 | Unexpired_Subscriptions],
                 Expired_Subscriptions}
        end);
%%
filter_expired_subscriptions(Notify_Sub, [Subscription | Subscriptions],
  Offline_Resource, Online_Resources,
  {Unexpired_Subscriptions, Expired_Subscriptions}) ->
    filter_expired_subscriptions(Notify_Sub, Subscriptions, Offline_Resource,
        Online_Resources,
        {[Subscription | Unexpired_Subscriptions], Expired_Subscriptions}).


%%
roster_process_item(Roster_Item, Server) ->
    spawn(pubsub_groups, monitor_roster_groups, [Server, Roster_Item]),
    Roster_Item.



roster_in_subscription(Boolean, User, Server, Jid_Contact,
  'subscribed' = _Subscription_Type) ->
    spawn(pubsub_groups, monitor_contacts2,
        ['subscribed', {User, Server, undefined}, Jid_Contact]),
    Boolean;
roster_in_subscription(Boolean, _User, _Server, _JID, _SubscriptionType) ->
    Boolean.