X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_minichat_conversation.erl;h=e46ca913d0dbe9ced0506e57b243ad0dedbf9672;hp=42412c6d3a08aedf0ef0551ba399af65dfb32479;hb=ff7d9f985ef60d59b652a8950dbbee204b276c87;hpb=13ea96f3600d1c42b22b6ea91dc75055555f72b7 diff --git a/modules/erl/euphorik_minichat_conversation.erl b/modules/erl/euphorik_minichat_conversation.erl index 42412c6..e46ca91 100755 --- a/modules/erl/euphorik_minichat_conversation.erl +++ b/modules/erl/euphorik_minichat_conversation.erl @@ -1,141 +1,204 @@ -% coding: utf-8 +% 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) -% Auteur : G.Burri -% Date : 09.02.2008 +% @author G.Burri +% +% @type Message() = {integer(), [integer()]} +% @type Conversation_detailee() = {[integer()], [integer()], [integer()], bool()} +% @type Conversation = {[Message()] , bool()} bool() : si true alors il y a encore des messages dans les pages suivantes. + --module(euphorik_minichat_conversation). - --include("euphorik_bd.hrl"). +-module(euphorik_minichat_conversation). +-export([ + conversations/4 +]). +-include("../include/euphorik_bd.hrl"). +-include("../include/euphorik_defines.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(euphorik_bd, [resultat_transaction/1]). +-import(qlc, [e/2, q/1]). -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. - +% Renvoie les conversations sous la forme d'une liste de conversation. +% Chaque conversation est un tuple {[{Message, Parents}], Plus} où +% Message est le message de type #minichat et Parents une liste d'Id. +% Plus est un bool. Si Plus vaut true alors il y a encore des messages. +% Si il n'y a pas de nouveaux message alors vide est renvoyé. +% Chaque racine est un tuple {R, P, D} +% 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()) -> [Conversation()] +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. +% @spec mise_en_forme_conversations([[integer()] | Conversation_detailee()]) -> [Conversation()] 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_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 message : [4, 5, 8, ...]. -mise_en_forme_conversation(Messages) -> - lists:map(fun(M) -> {euphorik_minichat:get_messages_depuis_ids(), get_parents(M)} end, Messages). +% Mise en forme d'une liste d'id de messages : [4, 5, 8, ...] -> [{4, [5, 6]}, ...]. +% Ajoute les parents de chaque message. +% @spec mise_en_forme_conversation([integer()]) -> [{integer(), [integer()]}] +mise_en_forme_conversation(Messages) -> + resultat_transaction(mnesia:transaction( + fun() -> + lists:foldr( + fun(Id, Acc) -> + case euphorik_bd:message_by_id(Id) of + {ok, Message} -> + [{Message, parents(Id)} | Acc]; + _ -> + Acc + end + end, + [], + Messages + ) + end + )). -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), +% @spec conversations_detailees([{integer(), integer()}], integer(), integer(), integer()) -> [[integer()] | 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), + Curseur = qlc:cursor( + qlc:sort(q([E#minichat.id || E <- table(minichat)]), [{order, descending}]), + [{tmpdir, ?KEY_SORT_TEMP_DIR}] + ), + {CP, Plus} = conversation_principale(Curseur, Conversations, N, P), qlc:delete_cursor(Curseur), - CP2 + {[M || M <- CP, M > D], Plus} % filtre en fonction de D end)), - [reverse(Conversation_principale) | Conversations]. + [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). +% @spec conversation_principale(qlc:QueryCursor(), [Conversation_detailee()], integer(), integer()) -> {[Id], Plus} +conversation_principale(C, 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(C, 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 + }. + + % 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, _) -> +% S est le nombre de messages qu'il faut sauter. +% @spec conversation_principale2(qlc:QueryCursor(), [integer()], integer(), integer()) +conversation_principale2(_, _, 0, _) -> []; -get_conversation_principale2(C, Messages, N, S) -> +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), + Doit_etre_saute = 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 + 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 + [M | 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 + 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ù +% 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], []), - {reverse(C), reverse(filter(fun(E) -> E > D end, sublist(C, N*(P-1)+1, N))), reverse(X)}. + 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 -conversation(Messages, [M | Reste], X) -> - Est_deja_traite = any(fun(E) -> E =:= M end, Messages), +% Attention : les messages de C et de X sont ordrés du plus grand Id au plus petit. +% @spec conversation([integer()], [integer()], [integer()]) -> {} +conversation(Conv, [M | Reste], X) -> + Est_deja_traite = any(fun(E) -> E =:= M end, Conv), 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) + conversation(Conv, Reste, X); + true -> + Enfants = enfants(M), + Parents = parents(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}. @@ -143,55 +206,36 @@ conversation(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) -> +% @spec enfants(integer()) -> [integer()] +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])) + e( + qlc:sort( + q([E#reponse_minichat.repondant || E <- table(reponse_minichat), E#reponse_minichat.cible =:= M]), + [{order, ascending}] + ), + [{tmpdir, ?KEY_SORT_TEMP_DIR}] + ) 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) -> +% ordrés du plus petit au plus grand.. +% @spec parents(integer()) -> [integer()] +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])) + e( + qlc:sort( + q([E#reponse_minichat.cible || E <- table(reponse_minichat), E#reponse_minichat.repondant =:= M]), + [{order, ascending}] + ), + [{tmpdir, ?KEY_SORT_TEMP_DIR}] + ) end)). % Intersection entre deux listes : [1, 3, 4] n [2, 4, 7] = [4] +% @spec intersection(list(term()), list(term())) -> list(term()) 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 + filter(fun(X) -> lists:member(X, L1) end, L2). +