X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_minichat_conversation.erl;h=e46ca913d0dbe9ced0506e57b243ad0dedbf9672;hp=0c762fbc597ed6a1bee9f7720204c7408a73e842;hb=ff7d9f985ef60d59b652a8950dbbee204b276c87;hpb=897468be6fa01ab87f38189f2daf266f3289c9fb diff --git a/modules/erl/euphorik_minichat_conversation.erl b/modules/erl/euphorik_minichat_conversation.erl index 0c762fb..e46ca91 100755 --- a/modules/erl/euphorik_minichat_conversation.erl +++ b/modules/erl/euphorik_minichat_conversation.erl @@ -1,129 +1,117 @@ -% 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]). --export([conversations/4]). % 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 la fonction est bloquante et attend un nouveau message. +% 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) -> - % écoute des nouveaux messages - case subscribe(minichat, 2) of - erreur = E -> - E; - _ -> - % demande des conversations - Conversations = conversations_detailees(Racines, N, D, P), - %io:format("~p~n", [Conversations]), - % si les conversations sont vides alors on attend un nouveau message - Vide = not lists:any( - fun(C) -> - case C of - {[], _} -> false; - {_, [], _, _} -> false; - _ -> true - end - end, - Conversations - ), - Conversations_mises_en_forme = mise_en_forme_conversations( - if Vide -> - attend_nouveau_message(), - conversations_detailees(Racines, N, D, P); - true -> - Conversations + 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 - ), - unsubscribe(minichat), - Conversations_mises_en_forme - end. - - -% Ecoute les événements de modification d'une table. -subscribe(_Table, 0) -> - erreur; -subscribe(Table, C) -> - case mnesia:subscribe({table, Table, simple}) of - {error, {not_active_local, Table}} -> - mnesia:add_table_copy(minichat, node(), ram_copies), - subscribe(Table, C - 1); - {error, _}-> - erreur; - _ -> - ok - end. - - -% Arrête d'écouter les modifications d'une table. -unsubscribe(Table) -> - mnesia:unsubscribe({table, Table, simple}). - - -% Attend qu'un nouveau message arrive, function bloquante. -% Renvoie le nouveau message. -attend_nouveau_message() -> - %io:format(F, "En attente d'un message !~n", []), - receive % attente d'un post - {mnesia_table_event, {write, Message, _}} -> - Message; - %io:format(F, "Debloquage !~n", []), - %file:close(F); - %~ {tcp_closed, _} -> - %~ mnesia:unsubscribe({table, minichat, simple}); - _ -> - %io:format(F, "~p~n", [M]), - attend_nouveau_message() - % 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 -> - timeout - 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, Plus_principale} | Conversations]) -> - [{mise_en_forme_conversation(Principale), Plus_principale} | lists:map(fun({_, Cn, _, Plus}) -> {mise_en_forme_conversation(Cn), Plus} end, 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, 5, 8, ...]. +% 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) -> - lists:map( - fun(Id) -> - {ok, Message} = euphorik_minichat:message_by_id(Id), - {Message, parents(Id)} - end, - 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 + )). + % 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. +% @spec conversations_detailees([{integer(), integer()}], integer(), integer(), integer()) -> [[integer()] | Conversation_detailee()] conversations_detailees(Racines, N, D, P) -> - Conversations = map(fun({Racine, P_conv}) -> conversation(Racine, N, D, P_conv) end, Racines), + 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}])])), + 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), - {reverse([M || M <- CP, M > D]), Plus} % filtre en fonction de D + {[M || M <- CP, M > D], Plus} % filtre en fonction de D end)), [Conversation_principale | Conversations]. @@ -132,9 +120,10 @@ conversations_detailees(Racines, N, D, P) -> % 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...) -% Renvoie {[Id], Plus} +% @spec conversation_principale(qlc:QueryCursor(), [Conversation_detailee()], integer(), integer()) -> {[Id], Plus} conversation_principale(C, Conversations, N, P) -> - CP = conversation_principale2(C, lists:flatten(map(fun({C2, _, X, _}) -> C2 -- X end, Conversations)), N + 1, (P - 1) * N), + % 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 -> @@ -149,15 +138,15 @@ conversation_principale(C, Conversations, N, P) -> % 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 +% S est le nombre de messages qu'il faut sauter. +% @spec conversation_principale2(qlc:QueryCursor(), [integer()], integer(), integer()) conversation_principale2(_, _, 0, _) -> []; 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 -> conversation_principale2(C, Messages, N, S); % le message ne fait pas partie de la conversation S =:= 0 -> @@ -178,18 +167,19 @@ conversation_principale2(C, Messages, N, S) -> % 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, - { + Decalage = N * (P - 1) + 1, + { reverse(C), if Decalage > length(C) -> []; true -> - reverse(filter( + filter( fun(E) -> E > D end, - sublist(C, Decalage, N) - )) + reverse(sublist(C, Decalage, N)) + ) end, reverse(X), Decalage + N - 1 < length(C) @@ -199,16 +189,16 @@ conversation(R, N, D, P) -> % 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()]) -> {} -conversation(Messages, [M | Reste], X) -> - Est_deja_traite = any(fun(E) -> E =:= M end, Messages), +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 = enfants(M), - Parents = 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}. @@ -219,7 +209,13 @@ conversation(Messages, [], X) -> % @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)). @@ -228,12 +224,18 @@ enfants(M) -> % @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). + filter(fun(X) -> lists:member(X, L1) end, L2).