modules/erl/minichat.erl

   1 % coding: utf-8
   2 % Ce module permet de gérer les données persistantes lié au minichat d'euphorik.ch
   3 % Il permet d'ajouter des message, de demande les messages sur une page donnée, etc..
   4 % Ce module utilise la base mnesia créée par le module euphorik_bd.
   5 % Auteur : G.Burri
   6 % Date : 22.10.2007
   7
   8 -module(minichat).
   9 -export([
  10    connect/0,
  11    % get :
  12    messages/1,
  13    messages/2,
  14    messages/3,
  15    conversation/2,
  16    reponses/0,
  17    repond_a/1,
  18    get_nb_page/1,
  19    users/0,
  20    get_user_by_cookie/1,
  21    get_user_by_id/1,
  22    get_user_by_login/1,
  23    get_user_by_login_password/2,
  24    possede_message/2,
  25    a_repondu_a_message/2,
  26    est_une_reponse_a_user/2,
  27    % set :
  28    update_pseudo_user/2,
  29    set_profile/6,
  30    update_date_derniere_connexion/1,
  31    nouveau_user/2,
  32    nouveau_user/3,
  33    nouveau_message/3,
  34    % autre :
  35    attends_nouveau_messages/0,
  36    tester/0,
  37    reset/0]).
  38
  39 -include("../include/euphorik_bd.hrl").
  40 -include_lib("stdlib/include/qlc.hrl").
  41
  42 % Un message est considéré comme du spam s'il est posté 1 seconde ou moins après le dernier posté
  43 -define(DUREE_SPAM, 1000). % ms
  44
  45 % Lorsque l'indice de spam d'un utilisateur atteind cette valeur alors il ne peut plus poster pendant un moment
  46 -define(INDICE_SPAM_MAX, 6).
  47
  48 % Un utilisateur ayant trop spamé est bloqué pendant ce temps
  49 -define(DUREE_BLOCAGE_SPAM, 20000). % ms
  50
  51
  52 % Quelques tests du modules.
  53 tester() ->
  54    aplu.
  55
  56
  57 % Connexion à la base de données de yaws sur overnux
  58 connect() ->
  59    mnesia:start(),
  60    mnesia:change_config(extra_db_nodes, [yaws@Plop]).
  61
  62
  63 % Efface tous les users, minichat_reponse et minichat.
  64 reset() ->
  65    mnesia:clear_table(counter),
  66    mnesia:clear_table(user),
  67    mnesia:clear_table(reponse_minichat),
  68    mnesia:clear_table(minichat),
  69    % crée l'utilisateur root
  70    mnesia:transaction(fun() ->
  71       User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now()},
  72       mnesia:write(User),
  73       User
  74    end).
  75
  76
  77 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
  78 % Renvoie {ok, User} ou erreur
  79 get_user_by_cookie(Cookie) ->
  80    resultat_transaction(mnesia:transaction(
  81       fun() ->
  82          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie])),
  83          case Users of
  84             [User] -> {ok, User};
  85             _ -> erreur
  86          end
  87       end
  88    )).
  89
  90
  91 get_user_by_id(ID) ->
  92    resultat_transaction(mnesia:transaction(
  93       fun() ->
  94          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= ID])),
  95          case Users of
  96             [User] -> {ok, User};
  97             _ -> erreur
  98          end
  99       end
 100    )).
 101
 102
 103 get_user_by_login(Login) ->
 104    resultat_transaction(mnesia:transaction(
 105       fun() ->
 106          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.login =:= Login])),
 107          case Users of
 108             [User] -> {ok, User};
 109             _ -> erreur
 110          end
 111       end
 112    )).
 113
 114
 115 get_user_by_login_password(Login, Password) ->
 116    resultat_transaction(mnesia:transaction(
 117       fun() ->
 118          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password])),
 119          case Users of
 120             [User] -> {ok, User};
 121             _ -> erreur
 122          end
 123       end
 124    )).
 125
 126
 127 % Renvoie l'utilisateur root
 128 get_root() ->
 129    {ok, User} = get_user_by_id(0),
 130    User.
 131
 132
 133 % Est-ce que Id_user possède Id_mess ?
 134 possede_message(Id_user, Id_mess) ->
 135    case mnesia:transaction(
 136             fun() ->
 137                qlc:e(qlc:q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]))
 138             end
 139          ) of
 140       {atomic, [Id_user | []]} -> true;
 141       _ -> false
 142    end.
 143
 144
 145 % Est-ce que Id_user à répondu au message Id_mess
 146 a_repondu_a_message(Id_user, Id_mess) ->
 147    case mnesia:transaction(
 148                fun() ->
 149                qlc:e(qlc:q([
 150                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 151                   R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
 152                ]), [{unique_all, true}])
 153             end
 154          ) of
 155       {atomic, [_]} -> true;
 156       _ -> false
 157    end.
 158
 159
 160 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
 161 est_une_reponse_a_user(Id_user, Id_mess) ->
 162    case mnesia:transaction(
 163                fun() ->
 164                qlc:e(qlc:q([
 165                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 166                   M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
 167                ]), [{unique_all, true}])
 168             end
 169          ) of
 170       {atomic, [_]} -> true;
 171       _ -> false
 172    end.
 173
 174
 175 % Met à jour le pseudo du user
 176 update_pseudo_user(UserId, Pseudo) ->
 177    mnesia:transaction(
 178       fun() ->
 179          case mnesia:wread({user, UserId}) of
 180             [User] when User#user.pseudo =/= Pseudo ->
 181                mnesia:write(User#user{pseudo = Pseudo});
 182             _ ->
 183                mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
 184           end
 185       end
 186    ).
 187
 188
 189 % Mise à par Cookie les autres peuvent être undefined ce qui veut dire qu'ils ne seront pas modifié.
 190 set_profile(Cookie, Login, Password, Pseudo, Email, Css) ->
 191    resultat_transaction(mnesia:transaction(
 192       fun() ->
 193          case get_user_by_cookie(Cookie) of
 194             {ok, User} ->
 195                case get_user_by_login(Login) of
 196                   {ok, U} when U#user.id =/= User#user.id ->
 197                      login_deja_pris;
 198                   _ ->
 199                      User_modifie = User#user{
 200                         login = if is_list(Login) -> Login; true -> User#user.login end,
 201                         password = if is_list(Password) -> Password; true -> User#user.password end,
 202                         pseudo = if is_list(Pseudo) -> Pseudo; true -> User#user.pseudo end,
 203                         email = if is_list(Email) -> Email; true -> User#user.email end,
 204                         css = if is_list(Css) -> Css; true -> User#user.css end
 205                      },
 206                      mnesia:write(User_modifie),
 207                      ok
 208                end;
 209             _ -> erreur
 210          end
 211       end
 212    )).
 213
 214
 215 % Met à jour la date de la dernière connexion d'un utilisateur à maintenant
 216 update_date_derniere_connexion(UserId) ->
 217    mnesia:transaction(
 218       fun() ->
 219          case mnesia:wread({user, UserId}) of
 220             [User] ->
 221                mnesia:write(User#user{date_derniere_connexion = now()});
 222             _ ->
 223                mnesia:abort("update_date_derniere_connexion: User inconnu")
 224           end
 225       end
 226    ).
 227
 228
 229 % Ajoute un nouveau user et le renvoie
 230 nouveau_user(Pseudo, Cookie) ->
 231    F = fun() ->
 232       Id = get_nouvel_id(user),
 233       User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()},
 234       mnesia:write(User),
 235       User
 236    end,
 237   resultat_transaction(mnesia:transaction(F)).
 238
 239
 240 % Ajoute un nouveau user et le renvoie
 241 nouveau_user(Login, Password, Cookie) ->
 242    F = fun() ->
 243       Id = get_nouvel_id(user),
 244       User = #user{id = Id, cookie = Cookie, pseudo = Login, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now()},
 245       mnesia:write(User),
 246       User
 247    end,
 248   resultat_transaction(mnesia:transaction(F)).
 249
 250
 251 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
 252 % retourne soit l'id du message soit erreur.
 253 nouveau_message(Mess, Auteur_id, Repond_A) ->
 254    % regarde si les id 'Repond_A' existent
 255    F = fun() ->
 256       Nb_id_trouve = length(qlc:e(qlc:q([E#minichat.id || E <- mnesia:table(minichat), lists:member(E#minichat.id, Repond_A)]))),
 257       % est-ce que l'auteur existe ?
 258       Auteur = case qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id])) of
 259          [A] -> A;
 260          _ -> throw("L'auteur du message est introuvable")
 261       end,
 262       if Nb_id_trouve =/= length(Repond_A) -> throw("Un ou plusieurs messages introuvable");
 263          true -> ok
 264       end,
 265       Id = get_nouvel_id(minichat),
 266       % compare les dernière
 267       Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
 268       Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
 269       Auteur_maj = Auteur#user{
 270          indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
 271          date_derniere_connexion = now()
 272       },
 273       % est-ce que l'auteur à trop floodé ?
 274       if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 275          Root = get_root(),
 276          mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
 277          mnesia:write(#minichat{id=Id, auteur_id=Root#user.id, date=now(), pseudo=Root#user.pseudo, contenu=Auteur#user.pseudo ++ "(" ++ Auteur#user.login ++ ") est bloqué pour " ++ integer_to_list(trunc(?DUREE_BLOCAGE_SPAM / 1000)) ++ " secondes pour cause de flood.."}),
 278          Id;
 279       Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 280          erreur;
 281       true ->
 282          mnesia:write(Auteur_maj),
 283          inserer_reponses(Id, Repond_A),
 284          mnesia:write(#minichat{id=Id, auteur_id=Auteur#user.id, date=now(), pseudo=Auteur#user.pseudo, contenu=Mess}),
 285          Id
 286       end
 287    end,
 288    resultat_transaction(mnesia:transaction(F)).
 289
 290
 291 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
 292 delta_date_ms(D1, D2) ->
 293    1000000000 * abs(element(1, D1) - element(1, D2)) + 1000 * abs(element(2, D1) - element(2, D2)) + trunc(abs(element(3, D1) - element(3, D2)) / 1000).
 294
 295
 296 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
 297 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
 298    mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
 299    inserer_reponses(Id_repondant, Reste);
 300 inserer_reponses(_, []) ->
 301    ok.
 302
 303
 304 % Renvoie un nouvel id pour une table donnée
 305 get_nouvel_id(Table) ->
 306    mnesia:dirty_update_counter(counter, Table, 1).
 307
 308
 309 % Attend qu'au moins un nouveau message arrive, function bloquante.
 310 attends_nouveau_messages() ->
 311    case mnesia:subscribe({table, minichat, simple}) of
 312       {error, _} = E -> E;
 313       _ ->
 314          %{ok, F} = file:open("/tmp/log_euphorik_" ++  pid_to_list(self()) ++ ".txt", [write]),
 315          %io:format(F, "Test2~n", []),
 316          attends_nouveau_messages2()
 317    end.
 318 attends_nouveau_messages2() ->
 319    %io:format(F, "En attente d'un message !~n", []),
 320    receive % attente d'un post
 321       {mnesia_table_event, {write, _, _}} ->
 322          mnesia:unsubscribe({table, minichat, simple});
 323          %io:format(F, "Debloquage !~n", []),
 324          %file:close(F);
 325       %~ {tcp_closed, _} ->
 326          %~ mnesia:unsubscribe({table, minichat, simple});
 327       _ ->
 328          %io:format(F, "~p~n", [M]),
 329          attends_nouveau_messages2()
 330    % 60 minutes de timeout (le cas ou il n'y a que des consultations et jamais de post)
 331    % Après 60 minutes de connexion, le client doit donc reétablir une connexion
 332    % 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)
 333    after 1000 * 60 * 60 ->
 334       mnesia:unsubscribe({table, minichat, simple})
 335    end.
 336
 337
 338 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
 339 % par page et que le dernier message que l'on possède est Id
 340 messages(Id, N, P) ->
 341    lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
 342
 343
 344 % Renvoie N messages se trouvant sur la page P
 345 messages(N, P) ->
 346    F = fun() ->
 347       C = qlc:cursor(qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, descending}])])),
 348       if P > 1 -> qlc:next_answers(C, N * (P - 1));
 349          true -> ok
 350       end,
 351       R = qlc:next_answers(C, N),
 352       qlc:delete_cursor(C),
 353       lists:reverse(R)
 354    end,
 355    resultat_transaction(mnesia:transaction(F)).
 356
 357
 358 % Renvoie N messages se trouvant sur la première page
 359 messages(N) ->
 360    messages(N, 1).
 361
 362
 363 % Renvoie les messages auquels répond M. M est l'id du message.
 364 % La réponse est sous la forme d'un arbre, par exemple : {M, [{3, [{1, []}]},{4, []}]}
 365 % ce qui signifie : M répond à 3 et à 4, 3 répond à 1.
 366 % N est le nombre de message sur une page
 367 conversation(M, N) ->
 368    P = page(M, N),
 369    {M, get_liste_cibles(M, N, P)}.
 370
 371
 372 % 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
 373 % P la page à laquelle se limite la recherche.
 374 % Voir 'conversation/2' pour plus de détail sur la structure retournée.
 375 get_liste_cibles(M, N, P) ->
 376    resultat_transaction(mnesia:transaction(fun() ->
 377       Cibles = qlc:e(qlc:q([E#reponse_minichat.cible || E <- mnesia:table(reponse_minichat), E#reponse_minichat.repondant =:= M])),
 378       lists:foldl(
 379          fun(E, A) ->
 380             PageE = page(E, N),
 381             if PageE =:= P -> % si E fait partit de la page de l'élément de base alors on le prend
 382                   [{E, get_liste_cibles(E, N, P)}| A];
 383                true ->
 384                   A
 385             end
 386          end, [], Cibles)
 387    end)).
 388
 389
 390 % Renvoie le nombre de page total en fonction du nombre de message par page N
 391 % TODO : ya pas un moyen moins pourri pour avoir le nombre de record d'une table ?
 392 get_nb_page(N) ->
 393    resultat_transaction(mnesia:transaction(fun() ->
 394       ceiling(length(qlc:e(qlc:q([E#minichat.id || E <- mnesia:table(minichat)]))) / N)
 395    end)).
 396
 397
 398 % Renvoie le numéro de la page sur lequel se trouve le message M en sachant qu'il y a N messages par page.
 399 page(M, N) ->
 400    resultat_transaction(mnesia:transaction(fun() ->
 401       ceiling((length(qlc:e(qlc:q([E || E <- mnesia:table(minichat), E#minichat.id >= M])))) / N)
 402    end)).
 403
 404
 405 % Bizarre, cette fonction n'existe pas dans la stdlib.
 406 ceiling(X) ->
 407    T = trunc(X),
 408    case (X - T) of
 409       Neg when Neg < 0 -> T;
 410       Pos when Pos > 0 -> T + 1;
 411       _ -> T
 412    end.
 413
 414
 415 % Renvoie tous les users.
 416 users() ->
 417    resultat_transaction(mnesia:transaction(fun() ->
 418       qlc:e(qlc:q([E || E <- mnesia:table(user)]))
 419    end)).
 420
 421
 422 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
 423 reponses() ->
 424    F = fun() ->
 425       qlc:e(qlc:q([E || E <- mnesia:table(reponse_minichat)]))
 426    end,
 427    resultat_transaction(mnesia:transaction(F)).
 428
 429 % Renvoie les messages auquel M_id répond.
 430 repond_a(M_id) ->
 431    resultat_transaction(mnesia:transaction(
 432       fun() ->
 433          qlc:e(qlc:q(
 434             [M || E <- mnesia:table(reponse_minichat),
 435             M <- mnesia:table(minichat),
 436             E#reponse_minichat.repondant =:= M_id,
 437             M#minichat.id =:= E#reponse_minichat.cible]))
 438       end
 439    )).
 440
 441
 442 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
 443 resultat_transaction({_, T}) ->
 444    T.
 445