X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_bd.erl;h=dff71dbf1fb68aef172c68509d213ac6b3c83c21;hp=a0ffc3ae1e0630a59b33d90b83db4117f8f20c39;hb=654e586482addf692991118ab9a4c5ead082457e;hpb=2424ba818818a6bd0b547fa540742f9b54db990b

diff --git a/modules/erl/euphorik_bd.erl b/modules/erl/euphorik_bd.erl
index a0ffc3a..dff71db 100755
--- a/modules/erl/euphorik_bd.erl
+++ b/modules/erl/euphorik_bd.erl
@@ -23,30 +23,21 @@
 
 
 -module(euphorik_bd).
--export([
-   % gestion :
-   create/0,
-   connect/0,
-   connect/1,
-   reset/0,
-   
+-export([   
    % users :
    nouveau_user/2,
-   nouveau_user/3,
-   set_profile/10,
+   nouveau_user/4,
+   set_profile/4,
    update_date_derniere_connexion/1,
    update_ip/2,
    update_pseudo_user/2,
-   print_users/0,
-   print_users/1,
-   print_user/1,
    user_by_cookie/1,   
    user_by_id/1,   
    user_by_login/1,
    user_by_login_password/2,
    user_by_mess/1,
-   toggle_ek_master/1,
    css_from_user_cookie/1,
+   is_ek_master_from_cookie/1,
    
    % messages :e
    nouveau_message/3,
@@ -61,6 +52,8 @@
    reponses/0,
    parents/1,
    enfants/1,
+   parents_id/1,
+   enfants_id/1,
    est_une_reponse_a_user/2,
    a_repondu_a_message/2,
    possede_message/2,
@@ -92,86 +85,11 @@
 -include_lib("stdlib/include/qlc.hrl").
 
 
-% Instructions pour créer une nouvelle base : 
-% $erl -sname yaws -mnesia dir '"/projets/euphorik/BD"'
-% voir doc/installation.txt
-% >l(euphorik_bd).
-% >euphorik_bd:create().
-create() ->
-   mnesia:stop(),
-   mnesia:delete_schema([node()]),
-   mnesia:create_schema([node()]), % nécessaire pour les tables sur disc
-   mnesia:start(),
-   create_tables(),
-   reset().
-   
-create_tables() ->
-   mnesia:create_table(counter, [
-      {attributes, record_info(fields, counter)},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(proprietes, [
-      {attributes, record_info(fields, proprietes)},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(minichat, [
-      {attributes, record_info(fields, minichat)},
-      {index, [auteur_id, troll_id]},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(reponse_minichat, [
-      {type, bag},
-      {attributes, record_info(fields, reponse_minichat)},
-      {index, [cible]},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(user, [
-      {attributes, record_info(fields, user)},
-      {index, [cookie, login]},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(ip_table, [
-      {attributes, record_info(fields, ip_table)},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(troll, [
-      {attributes, record_info(fields, troll)},
-      {index, [date_post]},
-      {disc_copies, [node()]}
-   ]).
-   
-   
-% Connexion à la base de données de yaws sur overnux
-connect() ->
-   connect(yaws@flynux).
-connect(Node) ->
-   mnesia:start(),
-   mnesia:change_config(extra_db_nodes, [Node]).
-
-
-% Efface tous les users, minichat_reponse et minichat.
-reset() ->
-   mnesia:clear_table(counter),
-   mnesia:clear_table(proprietes),
-   mnesia:clear_table(user),
-   mnesia:clear_table(reponse_minichat),
-   mnesia:clear_table(minichat),
-   mnesia:clear_table(troll),
-   mnesia:clear_table(ip_table),
-   % crée l'utilisateur root
-   mnesia:transaction(fun() ->
-      mnesia:write(#proprietes{nom = version, valeur = ?VERSION_BD}),
-      User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now(), ek_master = true},
-      mnesia:write(User),
-      User
-   end).
-
-
 % Ajoute un nouveau user et le renvoie
-nouveau_user(Pseudo, Cookie) ->
+nouveau_user(Cookie, Profile) ->
    F = fun() ->
       Id = nouvel_id(user),
-      User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()},
+      User = #user{id = Id, cookie = Cookie, date_creation = now(), date_derniere_connexion = now(), profile = Profile},
       mnesia:write(User),
       User
    end,
@@ -179,50 +97,39 @@ nouveau_user(Pseudo, Cookie) ->
   
   
 % Ajoute un nouveau user et le renvoie
-nouveau_user(Login, Password, Cookie) ->
+nouveau_user(Login, Password, Cookie, Profile) ->
    F = fun() ->
       Id = nouvel_id(user),
-      User = #user{id = Id, cookie = Cookie, pseudo = Login, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now()},
+      User = #user{id = Id, cookie = Cookie, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now(), profile = Profile#profile{pseudo = Login}},
       mnesia:write(User),
       User
    end,
   resultat_transaction(mnesia:transaction(F)).
+  
 
-
-% Mise à par Cookie les autres peuvent être undefined ce qui veut dire qu'ils ne seront pas modifié.
-set_profile(Cookie, Login, Password, Pseudo, Email, Css, Nick_format, View_times, View_tooltips, Conversations) ->
-   if Nick_format =:= nick; Nick_format =:= login; Nick_format =:= nick_login ->
-         resultat_transaction(mnesia:transaction(
-            fun() ->
-               case user_by_cookie(Cookie) of
-                  {ok, User} ->
-                     case user_by_login(Login) of
-                        {ok, U} when Login =/= [], U#user.id =/= User#user.id ->
-                           login_deja_pris;
-                        _ ->
-                           User_modifie = User#user{
-                              % TODO : pourquoi ne pas tester avec la valeur "undefined" plutôt qu'avec "is_list" ?
-                              % TODO : validation plus strict des données (pas de page négative dans les conv par exemple)
-                              login = if is_list(Login) -> Login; true -> User#user.login end,
-                              password = if is_list(Password) andalso Password =/= [] -> Password; true -> User#user.password end,
-                              pseudo = if is_list(Pseudo) -> Pseudo; true -> User#user.pseudo end,
-                              email = if is_list(Email) -> Email; true -> User#user.email end,
-                              css = if is_list(Css) -> Css; true -> User#user.css end,
-                              nick_format = Nick_format,
-                              view_times = View_times,
-                              view_tooltips = View_tooltips,
-                              conversations = if is_list(Conversations) -> Conversations; true -> User#user.conversations end
-                           },
-                           mnesia:write(User_modifie),
-                           ok
-                     end;
-                  _ -> erreur
-               end
-            end
-         ));
-      true ->
-         erreur
-   end.
+% Définit les données du profile d'une utilisateur.
+set_profile(Cookie, Login, Password, Profile) ->
+   resultat_transaction(mnesia:transaction(
+      fun() ->
+         case user_by_cookie(Cookie) of
+            {ok, User_existant} ->
+               case user_by_login(Login) of
+                  {ok, U} when Login =/= [], U#user.id =/= User_existant#user.id ->
+                     login_deja_pris;
+                  _ ->
+                     mnesia:write(
+                        User_existant#user{
+                           login = if User_existant#user.login =:= [] -> Login; true -> User_existant#user.login end, % on ne peut pas changer de login sauf si on en a pas !
+                           password = if Password =:= [] -> User_existant#user.password; true -> Password end,
+                           profile = Profile
+                        }
+                     ),
+                     ok
+               end;
+            _ -> erreur
+         end
+      end
+   )).
 
 
 % Met à jour la date de la dernière connexion d'un utilisateur à maintenant
@@ -236,7 +143,7 @@ update_date_derniere_connexion(User_id) ->
                mnesia:abort("update_date_derniere_connexion: User inconnu")
           end
       end
-   ).   
+   ).
 
 
 % Met à jour l'ip d'un user
@@ -258,83 +165,14 @@ update_pseudo_user(UserId, Pseudo) ->
    mnesia:transaction(
       fun() ->      
          case mnesia:wread({user, UserId}) of
-            [User] when User#user.pseudo =/= Pseudo ->
-               mnesia:write(User#user{pseudo = Pseudo});
+            [#user{profile = Profile} = User] when Profile#profile.pseudo =/= Pseudo ->
+               mnesia:write(User#user{profile = Profile#profile { pseudo = Pseudo } });
             _ ->
                mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
           end
       end
    ).
-   
-   
-% Affiche N user trié par leur date de dernière connexion.
-% Opt est une liste d'option d'affichage :
-%  * ekmaster : n'affiche que les admins
-print_users(N, Opt) ->
-   AfficheQueLesEkMaster = lists:any(fun(O) -> O =:= ekmaster end, Opt),
-   resultat_transaction(mnesia:transaction(fun() ->
-      C = cursor(
-         qlc:keysort(
-            #user.date_derniere_connexion, 
-            if AfficheQueLesEkMaster ->
-               q([E || E <- mnesia:table(user), E#user.ek_master =:= true]);
-            true ->
-               q([E || E <- mnesia:table(user)])
-            end,
-            [{order, descending}]
-         ),
-         [{tmpdir, ?KEY_SORT_TEMP_DIR}]
-      ),
-      Users = qlc:next_answers(C, N),
-      lists:foreach(
-         fun(U) ->
-            print_user(U)
-         end,
-         Users
-      ),
-      qlc:delete_cursor(C)
-   end)).
-   
-   
-% Affiche tous les users.
-print_users(Opt) ->
-   print_users(all_remaining, Opt).
-
-% Affiche tous les users.
-print_users() ->
-   print_users(all_remaining, []).
-   
-print_user(User) when is_record(User, user) ->
-   #user{id = Id, pseudo = Pseudo, login = Login, ek_master = Ek_master, date_derniere_connexion = Date, last_ip = IP} = User,
-   {{Annee, Mois, Jour}, {Heure, Min, _}} = calendar:now_to_local_time(Date),
-   io:format(
-      % id        pseudo     (login)        IP  Jour  Mois   Année  Heure Minute
-      "~4w : ~10.10..s(~10.10..s) ~s ~2w.~2.2.0w.~w - ~2wh~2.2.0w~n",
-      [  
-         Id,
-         if Ek_master -> "*"; true -> "" end ++ Pseudo,
-         Login,
-         euphorik_common:serialize_ip(IP),
-         Jour, Mois, Annee, Heure, Min
-      ]
-   );
-% Affichage d'un user en fonction de son login
-print_user(Login) when is_list(Login) ->
-   case user_by_login(Login) of
-      {ok, User} ->
-         print_user(User);
-      _ ->
-         {erreur, "Login pas trouvé : " ++ Login}
-   end;
-% Affichage d'un user en fonction de son id
-print_user(Id) when is_integer(Id) -> 
-   case user_by_id(Id) of 
-      {ok, User} ->
-         print_user(User);
-      _ ->
-         {erreur, "Id pas trouvé : " ++ integer_to_list(Id)}
-   end.
-   
+  
 
 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
 % Renvoie {ok, User} ou erreur
@@ -352,7 +190,11 @@ user_by_cookie(Cookie) ->
 user_by_id(ID) ->
    resultat_transaction(mnesia:transaction(
       fun() ->
-         case e(q([E || E <- mnesia:table(user), E#user.id =:= ID]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
+%         case e(q([E || E <- mnesia:table(user), E#user.id =:= ID]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
+%            [User] -> {ok, User};
+%            _ -> erreur
+%         end
+         case mnesia:read({user,  ID}) of
             [User] -> {ok, User};
             _ -> erreur
          end
@@ -371,29 +213,23 @@ user_by_login(Login) ->
       end
    )).
    
-   
-toggle_ek_master(User_id) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         Users = e(q([E || E <- mnesia:table(user), E#user.id =:= User_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]),
-         case Users of
-            [User] ->
-               mnesia:write(User#user{ek_master = not User#user.ek_master});
-            _ -> erreur
-         end
-      end
-   )).
-   
 
 % Renvoie une chaine représentant le cookie ou undefined si pas trouvé.
 css_from_user_cookie(Cookie) ->
    case user_by_cookie(Cookie) of 
-      {ok, User} ->
-         User#user.css;
+      {ok, #user{profile = Profile}} ->
+         Profile#profile.css;
       _ ->
          undefined
    end.
    
+   
+is_ek_master_from_cookie(Cookie) ->
+   case user_by_cookie(Cookie) of
+      {ok, #user{ek_master = true}} -> true;
+      _ -> false
+   end.
+   
 
 user_by_login_password(Login, Password) ->
    resultat_transaction(mnesia:transaction(
@@ -423,50 +259,62 @@ user_by_mess(Id) ->
 nouveau_message(Mess, Auteur_id, Repond_A_ids) ->
    % regarde si les id 'Repond_A' existent
    F = fun() ->   
-      Repond_A = e(
+      Repond_a = e(
          q([M || M <- mnesia:table(minichat), lists:member(M#minichat.id, Repond_A_ids)]),
          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
-      ),
-      Racine_id = case Repond_A of
+      ), 
+      Racine_id = case Repond_a of
          [] -> undefined;
-         [M | _ ] -> M#minichat.racine_id
-      end,
-      % est-ce que l'auteur existe ?
-      case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
-         [Auteur] ->
-            if length(Repond_A) =/= length(Repond_A_ids) ->
-                  {erreur, "Un ou plusieurs messages introuvable"};
+         [M | _ ] -> 
+            Une_racine = M#minichat.racine_id,
+            % vérification que tout les messages de Repond_a possède la même racine (même conversation)
+            case lists:all(fun(R) -> R#minichat.racine_id =:= Une_racine end, Repond_a) of
                true ->
-                  % comparaison entre la date du dernier poste et maintenant (gestion du flood)
-                  Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
-                  Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
-                  Auteur_maj = Auteur#user{
-                     indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
-                     date_derniere_connexion = now()
-                  },
-                  % est-ce que l'auteur à trop floodé ?
-                  if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
-                     mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
-                     nouveau_message_sys("''" ++ Auteur#user.pseudo ++ if Auteur#user.login =/= [] -> " (" ++ Auteur#user.login ++ ")"; true -> "" end ++ "'' est bloqué pour " ++ integer_to_list(trunc(?DUREE_BLOCAGE_SPAM / 1000)) ++ " secondes pour cause de flood.");
-                  Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
-                     {erreur, "Bloqué pour cause de flood"};
-                  true ->     
-                     mnesia:write(Auteur_maj),
-                     Id = nouvel_id(minichat),
-                     inserer_reponses(Id, Repond_A_ids),
-                     mnesia:write(#minichat{
-                        id = Id,
-                        auteur_id = Auteur#user.id,
-                        date = now(),
-                        pseudo = Auteur#user.pseudo,
-                        contenu = Mess,
-                        racine_id = if Racine_id =:= undefined -> Id; true -> Racine_id end
-                     }),
-                     Id
-                  end
-            end;
+                  Une_racine;
+               _ ->
+                  {erreur, "Les messages ne font pas partie de la même conversation"}
+            end
+      end,      
+      case Racine_id of
+         {erreur, E} -> {erreur, E};
          _ ->
-            {erreur, "L'auteur du message est introuvable"}
+            % est-ce que l'auteur existe ?
+            case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
+               [#user{profile = Profile} = Auteur] ->
+                  if length(Repond_a) =/= length(Repond_A_ids) ->
+                        {erreur, "Un ou plusieurs messages introuvable"};
+                     true ->
+                        % comparaison entre la date du dernier poste et maintenant (gestion du flood)
+                        Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
+                        Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
+                        Auteur_maj = Auteur#user{
+                           indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
+                           date_derniere_connexion = now()
+                        },
+                        % est-ce que l'auteur à trop floodé ?
+                        if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
+                           mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
+                           nouveau_message_sys("''" ++ Profile#profile.pseudo ++ if Auteur#user.login =/= [] -> " (" ++ Auteur#user.login ++ ")"; true -> "" end ++ "'' est bloqué pour " ++ integer_to_list(trunc(?DUREE_BLOCAGE_SPAM / 1000)) ++ " secondes pour cause de flood.");
+                        Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
+                           {erreur, "Bloqué pour cause de flood"};
+                        true ->     
+                           mnesia:write(Auteur_maj),
+                           Id = nouvel_id(minichat),
+                           inserer_reponses(Id, Repond_A_ids),
+                           mnesia:write(#minichat{
+                              id = Id,
+                              auteur_id = Auteur#user.id,
+                              date = now(),
+                              pseudo = Profile#profile.pseudo,
+                              contenu = Mess,
+                              racine_id = if Racine_id =:= undefined -> Id; true -> Racine_id end
+                           }),
+                           Id
+                        end
+                  end;
+               _ ->
+                  {erreur, "L'auteur du message est introuvable"}
+            end
       end
    end,
    resultat_transaction(mnesia:transaction(F)).
@@ -487,11 +335,11 @@ nouveau_message_sys(Mess) ->
 
 % Création d'un message système lié à un troll.
 nouveau_message_sys(Mess, Troll_id) ->
-   {ok, Root} = user_by_id(0),
+   {ok, #user{profile = Profile}} = user_by_id(0),
    resultat_transaction(mnesia:transaction(
       fun() ->
          Id = nouvel_id(minichat),
-         mnesia:write(#minichat{id=Id, auteur_id=0, date=now(), pseudo=Root#user.pseudo, contenu=Mess, troll_id=Troll_id, racine_id=Id}),
+         mnesia:write(#minichat{id = Id, auteur_id = 0, date = now(), pseudo = Profile#profile.pseudo, contenu = Mess, troll_id = Troll_id, racine_id = Id}),
          Id
       end
    )).
@@ -534,15 +382,14 @@ message_by_id(Id) ->
    resultat_transaction(mnesia:transaction(
       fun() ->
          case mnesia:read({minichat, Id}) of
-            [] -> erreur;
-            [M] ->
-               {ok, M#minichat{contenu = contenu_message(M)}}
+            [M] -> {ok, M#minichat{contenu = contenu_message(M)}};
+            _ -> erreur
          end
       end
    )).
    
    
-% Renvoie le contenu d'un message donnée, à utiliser à l'intérieur d'une transaction.
+% Renvoie le contenu d'un message donnée en fonction du troll associé, à utiliser à l'intérieur d'une transaction.
 % TODO : Cette fonction pourrait être remplacé par un "outer-join", est-ce possible avec qlc ?
 contenu_message(E) ->
    case mnesia:read({troll, E#minichat.troll_id}) of
@@ -607,35 +454,81 @@ enfants(M_id) ->
       end
    )).
    
+   
+% Renvoie les id des parents d'un message M (les messages auquels répond M)
+% ordrés du plus petit au plus grand..
+% On évite d'utiliser qlc pour des raisons de performance
+% @spec parents_id(integer()) -> [integer()]
+parents_id(M_id) ->
+   resultat_transaction(mnesia:transaction(fun() ->
+      case mnesia:read({reponse_minichat, M_id}) of
+         Parents when is_list(Parents) ->
+            lists:sort(lists:map(
+               fun(#reponse_minichat{cible = Cible}) -> Cible end,
+               Parents
+            ));
+         _ -> []            
+      end
+   end)).
+   
+   
+% Renvoie les id des enfants d'un message M (les messages qui répondent à M)
+% ordrés du plus petit au plus grand.
+% @spec enfants_id(integer()) -> [integer()]
+enfants_id(M) ->
+   resultat_transaction(mnesia:transaction(fun() ->
+      e(
+         qlc:sort(
+            q([E#reponse_minichat.repondant || E <- mnesia:table(reponse_minichat), E#reponse_minichat.cible =:= M]),
+            [{order, ascending}]
+         ),
+         [{tmpdir, ?KEY_SORT_TEMP_DIR}]
+      )
+   end)).
+     
 
 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
+% On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance.
 est_une_reponse_a_user(Id_user, Id_mess) ->
-   case mnesia:transaction(
-            fun() ->
-               e(q([
-                  M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
-                  M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
-               ]), [{unique_all, true}, {tmpdir, ?KEY_SORT_TEMP_DIR}])
-            end
-         ) of
-      {atomic, [_]} -> true;
-      _ -> false
-   end.
+   resultat_transaction(mnesia:transaction(
+      fun() ->
+         case mnesia:read({reponse_minichat, Id_mess}) of
+            [] -> false;
+            Cibles ->
+               lists:any(
+                  fun(#reponse_minichat{cible = Cible}) ->
+                     case mnesia:read({minichat, Cible}) of
+                        [#minichat{auteur_id = Id_user}] -> true;
+                        _ -> false
+                     end
+                  end,
+                  Cibles
+               )
+         end
+      end
+   )).
 
    
 % Est-ce que Id_user à répondu au message Id_mess
+% On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance.
 a_repondu_a_message(Id_user, Id_mess) ->
-   case mnesia:transaction(
-            fun() ->
-               e(q([
-                  M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
-                  R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
-               ]), [{unique_all, true}, {tmpdir, ?KEY_SORT_TEMP_DIR}])
-            end
-         ) of
-      {atomic, [_]} -> true;
-      _ -> false
-   end.
+   resultat_transaction(mnesia:transaction(
+      fun() ->
+         case mnesia:match_object({reponse_minichat, '_', Id_mess}) of
+            [] -> false;
+            Reponses ->
+               lists:any(
+                  fun(#reponse_minichat{repondant = Reponse}) ->
+                     case mnesia:read({minichat, Reponse}) of
+                        [#minichat{auteur_id = Id_user}] -> true;
+                        _ -> false
+                     end
+                  end,
+                  Reponses
+               )
+         end
+      end
+   )).
    
    
 % Est-ce que Id_user possède Id_mess ?
@@ -661,7 +554,7 @@ list_ban() ->
             {
                IP#ip_table.ip,
                delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now),
-               e(q([{U#user.pseudo, U#user.login} || U <- mnesia:table(user), U#user.last_ip =:= IP#ip_table.ip]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
+               e(q([{Profile#profile.pseudo, U#user.login} || #user{profile = Profile} = U <- mnesia:table(user), U#user.last_ip =:= IP#ip_table.ip]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
             } ||
             IP <- mnesia:table(ip_table),
             if IP#ip_table.ban =:= undefined -> false; true -> date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration) > Now end