X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_minichat_conversation.erl;h=4d0b3a8574d4f64e816c78076e96c280c99f8c01;hp=42412c6d3a08aedf0ef0551ba399af65dfb32479;hb=8ee1535f5594573931ddaebee77bf6148a5358cb;hpb=13ea96f3600d1c42b22b6ea91dc75055555f72b7 diff --git a/modules/erl/euphorik_minichat_conversation.erl b/modules/erl/euphorik_minichat_conversation.erl index 42412c6..4d0b3a8 100755 --- a/modules/erl/euphorik_minichat_conversation.erl +++ b/modules/erl/euphorik_minichat_conversation.erl @@ -1,197 +1,211 @@ -% coding: utf-8 -% Ce module permet la gestion des conversations du minichat d'euphorik. -% Un message (enfant) peut répondre à des messages (ses parents). -% Un message (parent) peut avoir plusieurs réponses (enfants) -% Auteur : G.Burri -% Date : 09.02.2008 +% coding: utf-8 +% Copyright 2008 Grégory Burri +% +% This file is part of Euphorik. +% +% Euphorik is free software: you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation, either version 3 of the License, or +% (at your option) any later version. +% +% Euphorik is distributed in the hope that it will be useful, +% but WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +% GNU General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with Euphorik. If not, see . +% +% Ce module permet la gestion des conversations du minichat d'euphorik. +% Un message (enfant) peut répondre à des messages (ses parents). +% Un message (parent) peut avoir plusieurs réponses (enfants) +% @author G.Burri +% +% Les conversation se compose d'une liste de tuple comprenant la conversation, du premier message de la conversation, +% et d'un booleen indiquant s'il y a encore des messages +% @type Conversations() = [{Conversation(), Message(), bool()}] +% +% Une conversation est simplement une liste de messages +% @type Conversation() = [Message()] +% +% Un message est un tuple représentant le message et la liste des id +% des messages auquels il répond +% @type Message() = {#minichat, [int()]} --module(euphorik_minichat_conversation). - --include("euphorik_bd.hrl"). --include_lib("stdlib/include/qlc.hrl"). - --import(lists, [reverse/1, any/2, map/2, sublist/3, filter/2]). --import(euphorik_minichat, [resultat_transaction/1]). --import(qlc, [e/1, q/1, keysort/3]). --import(mnesia, [table/1, transaction/1]). --compile(export_all). - - -% Renvoie la liste des cibles d'un message M, c'est à dire des messages auquel M répond. N étant le nombre de message par page et -% P la page à laquelle se limite la recherche. -% Voir 'conversation/2' pour plus de détail sur la structure retournée. -%~ get_liste_cibles(M, N, P) -> - %~ resultat_transaction(mnesia:transaction(fun() -> - %~ Cibles = qlc:e(qlc:q([E#reponse_minichat.cible || E <- mnesia:table(reponse_minichat), E#reponse_minichat.repondant =:= M])), - %~ lists:foldl( - %~ fun(E, A) -> - %~ PageE = page(E, N), - %~ if PageE =:= P -> % si E fait partit de la page de l'élément de base alors on le prend - %~ [{E, get_liste_cibles(E, N, P)}| A]; - %~ true -> - %~ A - %~ end - %~ end, [], Cibles) - %~ end)). - -tester(Racines, N, D, P) -> - io:format("~w~n", [conversations(Racines, N, D, P)]). - - -% Crée un process représentant le minichat, renvoie un tuple {Pid, Conversations} -start(Racines, N, D, P) -> - {mise_en_forme_conversations(loop(conversations(Racines, N, D, P))), conversations(Racines, N, D, P)}. - -% Attend pour d'autres messages. -wait(Pid) -> - Pid ! {wait, self()}, - receive - {nouveau, Message} -> Message - end. - - - -% Mise en forme des conversations pour l'utilisateur du module. -mise_en_forme_conversations([]) -> []; -mise_en_forme_conversations([Principale | Conversations]) -> - [mise_en_forme_conversation(Principale), lists:map(fun({_, Cn, _}) -> mise_en_forme_conversation(Cn) end, Conversations)]. - -% Mise en forme d'une liste d'id de message : [4, 5, 8, ...]. -mise_en_forme_conversation(Messages) -> - lists:map(fun(M) -> {euphorik_minichat:get_messages_depuis_ids(), get_parents(M)} end, Messages). - - -loop(Conversations) -> - receive - {wait, Pid} -> - Pid ! {nouveau, attends_nouveaux_messages()} - end, - loop(Conversations). - - -% Renvoie une liste de conversations, le première élément correspond à la conversation principale. -% Les autres éléments sont des tuples {C, Cn, X}, voir conversation/4 pour plus d'infos. -% Racines est une liste de tuple {Id, P} des racines des conversations ou P est la page et Id l'id du message. -conversations(Racines, N, D, P) -> - Conversations = map(fun({Racine, P_conv}) -> conversation(Racine, N, D, P_conv) end, Racines), + +-module(euphorik_minichat_conversation). +-export([ + conversations/4 +]). +-include("../include/euphorik_bd.hrl"). +-include("../include/euphorik_defines.hrl"). +-import(lists, [reverse/1, any/2, map/2, sublist/3, filter/2]). +-import(euphorik_bd, [resultat_transaction/1]). +-import(mnesia, [table/1, transaction/1]). + + +% Renvoie les conversations. +% Chaque racine est un tuple {R, P, D} +% R : l'id de la racine +% N : le nombre de message +% D : le dernier message connu, 0 si aucun +% P : la page souhaité, la premier est la 1 +% @spec conversations([{integer(), integer(), integer()}], integer(), integer(), integer()) -> Conversations() +conversations(Racines, N, D, P) -> + Conversations = conversations_detailees(Racines, N, D, P), + % si les conversations sont vides alors on attend un nouveau message + Vide = not any( + fun(C) -> + case C of + {[], _} -> false; + {_, [], _, _} -> false; + _ -> true + end + end, + Conversations + ), + if Vide -> + vide; + true -> + mise_en_forme_conversations(Conversations) + end. + + +% Mise en forme des conversations pour l'utilisateur du module. +% @type Conversation_principale() = {[integer()], bool} +% @type Conversation_detailee() = {[integer()], [integer()], [integer()], bool()} +% @spec mise_en_forme_conversations([Conversation_principal() | Conversation_detailee()]) -> [Conversation()] +mise_en_forme_conversations([]) -> []; +mise_en_forme_conversations([{Principale, Plus_principale} | Conversations]) -> + [{mise_en_forme_conversation(Principale), Plus_principale} | map(fun({_, Cn, _, Plus}) -> {mise_en_forme_conversation(Cn), Plus} end, Conversations)]. + + +% Mise en forme d'une liste d'id de messages : [4, 9, 8, ...] -> [{#minichat, [5, 6]}, ...]. +% Ajoute les parents de chaque message. +% @spec mise_en_forme_conversation([integer()]) -> [{#minichat, [integer()]}] +mise_en_forme_conversation(Messages) -> + resultat_transaction(transaction( + fun() -> + lists:foldr( + fun(Id, Acc) -> + case euphorik_bd:message_by_id(Id) of + {ok, Message} -> + [{Message, euphorik_bd:parents_id(Id)} | Acc]; + _ -> + Acc + end + end, + [], + Messages + ) + end + )). + + +% Renvoie une liste de conversations, le première élément correspond à la conversation principale. +% Les autres éléments sont des tuples {C, Cn, X, Plus}, voir conversation/4 pour plus d'infos. +% Racines est une liste de tuple {Id, P} des racines des conversations ou P est la page et Id l'id du message. +% @spec conversations_detailees([{integer(), integer()}], integer(), integer(), integer()) -> [[{integer(), bool()}] | Conversation_detailee()] +conversations_detailees(Racines, N, D, P) -> + Conversations = map(fun({Racine, P_conv, Dernier}) -> conversation(Racine, N, Dernier, P_conv) end, Racines), Conversation_principale = resultat_transaction(transaction(fun() -> - Curseur = qlc:cursor(q([E#minichat.id || E <- qlc:sort(table(minichat), [{order, descending}])])), - CP2 = get_conversation_principale(Curseur, Conversations, N, P), - qlc:delete_cursor(Curseur), - CP2 - end)), - [reverse(Conversation_principale) | Conversations]. - - -% Construit la conversation principale en fonction d'un curseur C initialement placé sur le dernier message -% et la liste de conversations. -% N est le nombre de messages que l'on souhaite. -% P est le numéro de la page (1, 2, 3...) -get_conversation_principale(C, Conversations, N, P) -> - get_conversation_principale2(C, lists:flatten(map(fun({C2, _, X}) -> C2 -- X end, Conversations)), N, (P - 1) * N). -% C est le curseur (voir ci dessus) -% 'Messages' sont les messages que l'on doit enlever de la conversation -% S est le nombre de messages qu'il faut sauter -get_conversation_principale2(_, _, 0, _) -> + Dernier_id = mnesia:last(minichat), + {CP, Plus} = conversation_principale(Dernier_id, Conversations, N, P), + {[M || M <- CP, M > D], Plus} % filtre en fonction de D + end)), + [Conversation_principale | Conversations]. + + +% Construit la conversation principale en fonction d'un id de message initialement placé sur le dernier message +% et la liste de conversations. +% N est le nombre de messages que l'on souhaite. +% P est le numéro de la page (1, 2, 3...) +% @spec conversation_principale(integer(), [Conversation_detailee()], integer(), integer()) -> {[integer()], bool()} +conversation_principale(Id, Conversations, N, P) -> + % on prend en message de plus pour savoir s'il y en a plus que ce que l'on désire + CP = reverse(conversation_principale2(Id, lists:flatten(map(fun({C2, _, X, _}) -> C2 -- X end, Conversations)), N + 1, (P - 1) * N)), + Plus = length(CP) =:= N + 1, + { + if Plus -> + [_| Suivants] = CP, + Suivants; + true -> + CP + end, + Plus + }. + + +% Id est l'id d'un message, voir ce dessus +% 'Messages' sont les messages que l'on doit enlever de la conversation +% S est le nombre de messages qu'il faut sauter. +% @spec conversation_principale2(integer(), [integer()], integer(), integer()) -> [integer()] +conversation_principale2(_, _, 0, _) -> []; -get_conversation_principale2(C, Messages, N, S) -> - case qlc:next_answers(C, 1) of - [] -> []; - [M] -> % traitement message par message (pas des plus performant :/) - %io:format("M: ~p~n", [M]), - Doit_etre_saute = lists:any(fun(E) -> E == M end, Messages), - if Doit_etre_saute -> - get_conversation_principale2(C, Messages, N, S); % le message ne fait pas partie de la conversation - S =:= 0 -> - [M | get_conversation_principale2(C, Messages, N - 1, S)]; % ok : le message fait partie de la conversation - true -> - get_conversation_principale2(C, Messages, N, S - 1) % on n'a pas encore atteint le début de la page - end - end. - - -% Renvoie un tuple {C, Cn, X} où -% C : La conversation complète -% Cn : La conversation tronqué en fonction de N, D et P -% X : La liste des messages répondant à des mess qui ne font pas partie de la conversation -% Inputs : -% R : l'id d'un message représentant la racine de la conversation -% N : le nombre de message par page -% D : Le dernier message connu 0 si aucun de connu -% P : La page désirée -conversation(R, N, D, P) -> - {C, X} = conversation([], [R], []), - {reverse(C), reverse(filter(fun(E) -> E > D end, sublist(C, N*(P-1)+1, N))), reverse(X)}. - - -% Renvoie un tuple {C, X} où C est la conversation complète et X les messages répondant à des mess qui ne font pas partie de la conversation -% Attention : les messages de C et de X sont ordrés du plus grand Id au plus petit -conversation(Messages, [M | Reste], X) -> - Est_deja_traite = any(fun(E) -> E =:= M end, Messages), - if Est_deja_traite -> - conversation(Messages, Reste, X); - true -> - Enfants = get_enfants(M), - Parents = get_parents(M), - % un message est dit exiterne si un de ses parent ne fait pas partie de la conversation ou si un de ses parents fait partie de X - Est_message_externe = Parents -- Messages =/= [] orelse intersection(Parents, X) =/= [], - conversation([M | Messages], Reste ++ Enfants, if Est_message_externe -> [M | X]; true -> X end) - end; -conversation(Messages, [], X) -> - {Messages, X}. - - -% Renvoie les enfants d'un message M (les messages qui répondent à M) -% ordrés du plus petit au plus grand. -get_enfants(M) -> - resultat_transaction(transaction(fun() -> - e(q([E#reponse_minichat.repondant || E <- qlc:sort(table(reponse_minichat), [{order, ascending}]), E#reponse_minichat.cible =:= M])) - end)). - - -% Renvoie les parents d'un message M (les messages auquels répond M) -% ordrés du plus petit au plus grand. -get_parents(M) -> - resultat_transaction(transaction(fun() -> - e(q([E#reponse_minichat.cible || E <- keysort(1, table(reponse_minichat), [{order, ascending}]), E#reponse_minichat.repondant =:= M])) - end)). - - -% Intersection entre deux listes : [1, 3, 4] n [2, 4, 7] = [4] -intersection(L1, L2) -> - lists:filter(fun(X) -> lists:member(X, L1) end, L2). - - -% Attend qu'au moins un nouveau message arrive, function bloquante. -% Renvoie un tuple {C, M} où C est une liste de numéro de conversation auquel appartient M et M l'Id du nouveau message -attends_nouveaux_messages() -> - case mnesia:subscribe({table, minichat, simple}) of - {error, _} = E -> E; - _ -> - %{ok, F} = file:open("/tmp/log_euphorik_" ++ pid_to_list(self()) ++ ".txt", [write]), - %io:format(F, "Test2~n", []), - attends_nouveaux_messages2() - end. -attends_nouveaux_messages2() -> - %io:format(F, "En attente d'un message !~n", []), - receive % attente d'un post - {mnesia_table_event, {write, _, _}} -> - mnesia:unsubscribe({table, minichat, simple}); - %io:format(F, "Debloquage !~n", []), - %file:close(F); - %~ {tcp_closed, _} -> - %~ mnesia:unsubscribe({table, minichat, simple}); - _ -> - %io:format(F, "~p~n", [M]), - attends_nouveaux_messages2() - % 60 minutes de timeout (le cas ou il n'y a que des consultations et jamais de post) - % Après 60 minutes de connexion, le client doit donc reétablir une connexion - % TODO : pour être mieux : quand le socket se ferme alors un message devrait être envoyé et débloquer ce receive (demande en cours sur la mailing list de yaws) - after 1000 * 60 * 60 -> - mnesia:unsubscribe({table, minichat, simple}) - end. - - - - - \ No newline at end of file +conversation_principale2('$end_of_table', _, _, _) -> + []; +conversation_principale2(Id, Messages, N, S) -> + % traitement message par message (pas des plus performant :/) + Id_prev = mnesia:prev(minichat, Id), + Doit_etre_saute = any(fun(E) -> E == Id end, Messages), + if Doit_etre_saute -> + conversation_principale2(Id_prev, Messages, N, S); % le message ne fait pas partie de la conversation + S =:= 0 -> + [Id | conversation_principale2(Id_prev, Messages, N - 1, S)]; % ok : le message fait partie de la conversation + true -> + conversation_principale2(Id_prev, Messages, N, S - 1) % on n'a pas encore atteint le début de la page + end. + + +% Renvoie un tuple {C, Cn, X, Plus} où +% C : La conversation complète +% Cn : La conversation tronqué en fonction de N, D et P +% X : La liste des messages répondant à des mess qui ne font pas partie de la conversation +% Plus : true s'il y a encore des messages après +% Inputs : +% R : l'id d'un message représentant la racine de la conversation +% N : le nombre de message par page +% D : Le dernier message connu 0 si aucun de connu +% P : La page désirée +% @spec conversation([integer()], integer(), integer(), integer()) -> Conversation_detailee() +conversation(R, N, D, P) -> + {C, X} = conversation([], [R], []), + Decalage = N * (P - 1) + 1, + { + reverse(C), + if Decalage > length(C) -> + []; + true -> + filter( + fun(E) -> E > D end, + reverse(sublist(C, Decalage, N)) + ) + end, + reverse(X), + Decalage + N - 1 < length(C) + }. + + +% Renvoie un tuple {C, X} où C est la conversation complète et X les messages répondant à des mess qui ne font pas partie de la conversation +% Attention : les messages de C et de X sont ordrés du plus grand Id au plus petit. +% @spec conversation([integer()], [integer()], [integer()]) -> {[int()], [int()]} +conversation(Conv, [M | Reste], X) -> + Est_deja_traite = any(fun(E) -> E =:= M end, Conv), + if Est_deja_traite -> + conversation(Conv, Reste, X); + true -> + Enfants = euphorik_bd:enfants_id(M), + Parents = euphorik_bd:parents_id(M), + % un message est dit externe si un de ses parent ne fait pas partie de la conversation ou si un de ses parents fait partie de X + Est_message_externe = Parents -- Conv =/= [] orelse intersection(Parents, X) =/= [], + conversation([M | Conv], lists:merge(Reste, Enfants), if Est_message_externe -> [M | X]; true -> X end) + end; +conversation(Messages, [], X) -> + {Messages, X}. + + +% Intersection entre deux listes : [1, 3, 4] n [2, 4, 7] = [4] +% @spec intersection(list(term()), list(term())) -> list(term()) +intersection(L1, L2) -> + filter(fun(X) -> lists:member(X, L1) end, L2). +