modules/erl/euphorik_bd.erl

   1 % coding: utf-8
   2 % Ce module permet de gérer les données persistantes lié au site d'euphorik.ch.
   3 % Il permet d'ajouter des message, de demande les messages sur une page donnée, etc..
   4 % Ce module utilise une base mnesia.
   5 % @author G.Burri
   6
   7 -module(euphorik_bd).
   8 -export([
   9    % gestion :
  10    create/0,
  11    connect/0,
  12    connect/1,
  13    reset/0,
  14
  15    % users :
  16    nouveau_user/2,
  17    nouveau_user/3,
  18    set_profile/9,
  19    update_date_derniere_connexion/1,
  20    update_ip/2,
  21    update_pseudo_user/2,
  22    print_users/0,
  23    print_users/1,
  24    user_by_cookie/1,
  25    user_by_id/1,
  26    user_by_login/1,
  27    user_by_login_password/2,
  28    user_by_mess/1,
  29    toggle_ek_master/1,
  30
  31    % messages :
  32    nouveau_message/3,
  33    nouveau_message_sys/1,
  34    messages/1,
  35    messages/2,
  36    messages/3,
  37    message_by_id/1,
  38    messages_by_ids/1,
  39    message_existe/1,
  40    reponses/0,
  41    repond_a/1,
  42    est_une_reponse_a_user/2,
  43    a_repondu_a_message/2,
  44    possede_message/2,
  45
  46    % ip :
  47    ip_table/0,
  48    ban/2,
  49    deban/1,
  50    est_banni/1,
  51    can_register/1,
  52
  53    % trolls :
  54    trolls/0,
  55    trolls/1,
  56    trolls_attente/1,
  57    put_troll/2,
  58    mod_troll/2,
  59    del_troll/1,
  60    troll_by_id/1,
  61    current_troll/0,
  62    elire_troll/0,
  63
  64    % versions :
  65    update_version/1,
  66
  67    % utiles :
  68    resultat_transaction/1
  69 ]).
  70
  71 -import(qlc, [e/1, e/2, q/1, cursor/1]).
  72
  73 -include("../include/euphorik_bd.hrl").
  74 -include("../include/euphorik_defines.hrl").
  75 -include_lib("stdlib/include/qlc.hrl").
  76
  77
  78 % Instructions pour créer une nouvelle base :
  79 % $erl -sname yaws -mnesia dir '"/projets/euphorik/BD"'
  80 % voir doc/installation.txt
  81 % >l(euphorik_bd).
  82 % >euphorik_bd:create().
  83 create() ->
  84    mnesia:stop(),
  85    mnesia:delete_schema([node()]),
  86    mnesia:create_schema([node()]), % nécessaire pour les tables sur disc
  87    mnesia:start(),
  88    create_tables(),
  89    reset().
  90 create_tables() ->
  91    mnesia:create_table(counter, [
  92       {attributes, record_info(fields, counter)},
  93       {disc_copies, [node()]}
  94    ]),
  95    mnesia:create_table(minichat, [
  96       {attributes, record_info(fields, minichat)},
  97       {index, [auteur_id]},
  98       {disc_copies, [node()]}
  99    ]),
 100    mnesia:create_table(reponse_minichat, [
 101       {type, bag},
 102       {attributes, record_info(fields, reponse_minichat)},
 103       {index, [cible]},
 104       {disc_copies, [node()]}
 105    ]),
 106    mnesia:create_table(user, [
 107       {attributes, record_info(fields, user)},
 108       {index, [cookie, login]},
 109       {disc_copies, [node()]}
 110    ]),
 111    mnesia:create_table(ip_table, [
 112       {attributes, record_info(fields, ip_table)},
 113       {disc_copies, [node()]}
 114    ]),
 115    mnesia:create_table(troll, [
 116       {attributes, record_info(fields, troll)},
 117       {index, [date_post]},
 118       {disc_copies, [node()]}
 119    ]).
 120
 121
 122 % Connexion à la base de données de yaws sur overnux
 123 connect() ->
 124    connect(yaws@flynux).
 125 connect(Node) ->
 126    mnesia:start(),
 127    mnesia:change_config(extra_db_nodes, [Node]).
 128
 129
 130 % Efface tous les users, minichat_reponse et minichat.
 131 reset() ->
 132    mnesia:clear_table(counter),
 133    mnesia:clear_table(user),
 134    mnesia:clear_table(reponse_minichat),
 135    mnesia:clear_table(minichat),
 136    mnesia:clear_table(troll),
 137    mnesia:clear_table(ip_table),
 138    % crée l'utilisateur root
 139    mnesia:transaction(fun() ->
 140       User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now(), ek_master = true},
 141       mnesia:write(User),
 142       User
 143    end).
 144
 145
 146 % Ajoute un nouveau user et le renvoie
 147 nouveau_user(Pseudo, Cookie) ->
 148    F = fun() ->
 149       Id = nouvel_id(user),
 150       User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()},
 151       mnesia:write(User),
 152       User
 153    end,
 154   resultat_transaction(mnesia:transaction(F)).
 155
 156
 157 % Ajoute un nouveau user et le renvoie
 158 nouveau_user(Login, Password, Cookie) ->
 159    F = fun() ->
 160       Id = nouvel_id(user),
 161       User = #user{id = Id, cookie = Cookie, pseudo = Login, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now()},
 162       mnesia:write(User),
 163       User
 164    end,
 165   resultat_transaction(mnesia:transaction(F)).
 166
 167
 168 % Mise à par Cookie les autres peuvent être undefined ce qui veut dire qu'ils ne seront pas modifié.
 169 set_profile(Cookie, Login, Password, Pseudo, Email, Css, Nick_format, Page_principale, Conversations) ->
 170    if Nick_format =:= nick; Nick_format =:= login; Nick_format =:= nick_login ->
 171          resultat_transaction(mnesia:transaction(
 172             fun() ->
 173                case user_by_cookie(Cookie) of
 174                   {ok, User} ->
 175                      case user_by_login(Login) of
 176                         {ok, U} when Login =/= [], U#user.id =/= User#user.id ->
 177                            login_deja_pris;
 178                         _ ->
 179                            User_modifie = User#user{
 180                               % TODO : pourquoi ne pas tester avec la valeur "undefined" plutôt qu'avec "is_list" ?
 181                               % TODO : validation plus strict des données (pas de page négative dans les conv par exemple)
 182                               login = if is_list(Login) -> Login; true -> User#user.login end,
 183                               password = if is_list(Password) andalso Password =/= [] -> Password; true -> User#user.password end,
 184                               pseudo = if is_list(Pseudo) -> Pseudo; true -> User#user.pseudo end,
 185                               email = if is_list(Email) -> Email; true -> User#user.email end,
 186                               css = if is_list(Css) -> Css; true -> User#user.css end,
 187                               nick_format = Nick_format,
 188                               page_principale = if is_integer(Page_principale), Page_principale > 0 -> Page_principale; true -> User#user.page_principale end,
 189                               conversations = if is_list(Conversations) -> Conversations; true -> User#user.conversations end
 190                            },
 191                            mnesia:write(User_modifie),
 192                            ok
 193                      end;
 194                   _ -> erreur
 195                end
 196             end
 197          ));
 198       true ->
 199          erreur
 200    end.
 201
 202
 203 % Met à jour la date de la dernière connexion d'un utilisateur à maintenant
 204 update_date_derniere_connexion(User_id) ->
 205    mnesia:transaction(
 206       fun() ->
 207          case mnesia:wread({user, User_id}) of
 208             [User] ->
 209                mnesia:write(User#user{date_derniere_connexion = now()});
 210             _ ->
 211                mnesia:abort("update_date_derniere_connexion: User inconnu")
 212           end
 213       end
 214    ).
 215
 216
 217 % Met à jour l'ip d'un user
 218 update_ip(User_id, IP) ->
 219    mnesia:transaction(
 220       fun() ->
 221          case mnesia:wread({user, User_id}) of
 222             [User] ->
 223                mnesia:write(User#user{last_ip = IP});
 224             _ ->
 225                mnesia:abort("update_ip: User inconnu")
 226           end
 227       end
 228    ).
 229
 230
 231 % Met à jour le pseudo du user
 232 update_pseudo_user(UserId, Pseudo) ->
 233    mnesia:transaction(
 234       fun() ->
 235          case mnesia:wread({user, UserId}) of
 236             [User] when User#user.pseudo =/= Pseudo ->
 237                mnesia:write(User#user{pseudo = Pseudo});
 238             _ ->
 239                mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
 240           end
 241       end
 242    ).
 243
 244
 245 % Affiche N user trié par leur date de dernière connexion.
 246 % Attention : pas d'index sur ce champs (la date)
 247 print_users(N) ->
 248    resultat_transaction(mnesia:transaction(fun() ->
 249       C = cursor(q([E || E <- qlc:keysort(9, mnesia:table(user), [{order, descending}])])),
 250       Users = qlc:next_answers(C, N),
 251       lists:foreach(
 252          fun(U) ->
 253             #user{id = Id, pseudo = Pseudo, login = Login, ek_master = Ek_master, date_derniere_connexion = Date} = U,
 254             {{Annee, Mois, Jour}, {Heure, Min, _}} = calendar:now_to_local_time(Date),
 255             io:format(
 256                "~4w : ~10.10..s~10.10..s ~2w.~2.2.0w.~w - ~2wh~2.2.0w~n",
 257                [
 258                   Id,
 259                   if Ek_master -> "*"; true -> "" end ++ Pseudo,
 260                   "(" ++ Login ++ ")",
 261                   Jour, Mois, Annee, Heure, Min
 262                ]
 263             )
 264          end,
 265          Users
 266       ),
 267       qlc:delete_cursor(C)
 268    end)).
 269
 270
 271 % Affiche tous les users.
 272 print_users() ->
 273    print_users(all_remaining).
 274
 275
 276 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
 277 % Renvoie {ok, User} ou erreur
 278 user_by_cookie(Cookie) ->
 279    resultat_transaction(mnesia:transaction(
 280       fun() ->
 281          case e(q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie])) of
 282             [User] -> {ok, User};
 283             _ -> erreur
 284          end
 285       end
 286    )).
 287
 288
 289 user_by_id(ID) ->
 290    resultat_transaction(mnesia:transaction(
 291       fun() ->
 292          case e(q([E || E <- mnesia:table(user), E#user.id =:= ID])) of
 293             [User] -> {ok, User};
 294             _ -> erreur
 295          end
 296       end
 297    )).
 298
 299
 300 user_by_login(Login) ->
 301    resultat_transaction(mnesia:transaction(
 302       fun() ->
 303          Users = e(q([E || E <- mnesia:table(user), E#user.login =:= Login])),
 304          case Users of
 305             [User] -> {ok, User};
 306             _ -> erreur
 307          end
 308       end
 309    )).
 310
 311
 312 toggle_ek_master(User_id) ->
 313    resultat_transaction(mnesia:transaction(
 314       fun() ->
 315          Users = e(q([E || E <- mnesia:table(user), E#user.id =:= User_id])),
 316          case Users of
 317             [User] ->
 318                mnesia:write(User#user{ek_master = not User#user.ek_master});
 319             _ -> erreur
 320          end
 321       end
 322    )).
 323
 324
 325 user_by_login_password(Login, Password) ->
 326    resultat_transaction(mnesia:transaction(
 327       fun() ->
 328          case e(q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password])) of
 329             [User | _] -> {ok, User};
 330             _ -> erreur
 331          end
 332       end
 333    )).
 334
 335
 336 % Renvoie {ok, User} où User est un #user possédant le message donné.
 337 user_by_mess(Id) ->
 338    resultat_transaction(mnesia:transaction(
 339       fun() ->
 340          case e(q([U || U <- mnesia:table(user), M <- mnesia:table(minichat), M#minichat.id =:= Id, M#minichat.auteur_id =:= U#user.id])) of
 341             [User | _] -> {ok, User};
 342             _ -> erreur
 343          end
 344       end
 345    )).
 346
 347
 348 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
 349 % retourne soit l'id du message soit erreur.
 350 nouveau_message(Mess, Auteur_id, Repond_A) ->
 351    % regarde si les id 'Repond_A' existent
 352    F = fun() ->
 353       Nb_id_trouve = length(e(q([E#minichat.id || E <- mnesia:table(minichat), lists:member(E#minichat.id, Repond_A)]))),
 354       % est-ce que l'auteur existe ?
 355       Auteur = case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id])) of
 356          [A] -> A;
 357          _ -> throw("L'auteur du message est introuvable")
 358       end,
 359       if Nb_id_trouve =/= length(Repond_A) -> throw("Un ou plusieurs messages introuvable");
 360          true -> ok
 361       end,
 362       % compare les dernière
 363       Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
 364       Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
 365       Auteur_maj = Auteur#user{
 366          indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
 367          date_derniere_connexion = now()
 368       },
 369       % est-ce que l'auteur à trop floodé ?
 370       if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 371          mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
 372          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.");
 373       Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 374          erreur;
 375       true ->
 376          mnesia:write(Auteur_maj),
 377          Id = nouvel_id(minichat),
 378          inserer_reponses(Id, Repond_A),
 379          mnesia:write(#minichat{id=Id, auteur_id=Auteur#user.id, date=now(), pseudo=Auteur#user.pseudo, contenu=Mess}),
 380          Id
 381       end
 382    end,
 383    resultat_transaction(mnesia:transaction(F)).
 384
 385 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
 386 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
 387    mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
 388    inserer_reponses(Id_repondant, Reste);
 389 inserer_reponses(_, []) ->
 390    ok.
 391
 392
 393 % Permet de créer un message système.
 394 % Renvoie l'id du message système
 395 nouveau_message_sys(Mess) ->
 396    {ok, Root} = user_by_id(0),
 397    mnesia:transaction(
 398       fun() ->
 399          Id = nouvel_id(minichat),
 400          mnesia:write(#minichat{id=Id, auteur_id=0, date=now(), pseudo=Root#user.pseudo, contenu=Mess})
 401       end
 402    ).
 403
 404
 405 % Renvoie N messages se trouvant sur la première page
 406 messages(N) ->
 407    messages(N, 1).
 408
 409
 410 % Renvoie N messages se trouvant sur la page P
 411 messages(N, P) ->
 412    F = fun() ->
 413       C = cursor(q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, descending}])])),
 414       if P > 1 -> qlc:next_answers(C, N * (P - 1));
 415          true -> ok
 416       end,
 417       R = qlc:next_answers(C, N),
 418       qlc:delete_cursor(C),
 419       lists:reverse(R)
 420    end,
 421    resultat_transaction(mnesia:transaction(F)).
 422
 423
 424 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
 425 % par page et que le dernier message que l'on possède est Id
 426 messages(Id, N, P) ->
 427    lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
 428
 429
 430 % Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
 431 message_by_id(Id) ->
 432    case resultat_transaction(mnesia:transaction(
 433       fun() ->
 434          e(q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), Id =:= E#minichat.id]))
 435       end
 436    )) of
 437       [M] -> {ok, M};
 438       _ -> erreur
 439    end.
 440
 441
 442 % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
 443 messages_by_ids(Ids) ->
 444    resultat_transaction(mnesia:transaction(
 445       fun() ->
 446          % TODO : optimisations ? serait-ce du O(n) ?
 447          Query = q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
 448          e(Query)
 449       end
 450    )).
 451
 452
 453 % Est-ce qu'un message existe ? Renvoie un boolean.
 454 % TODO : ya pas plus simple ?
 455 message_existe(Id) ->
 456    resultat_transaction(mnesia:transaction(fun() ->
 457       length(e(q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]))) =:= 1
 458    end)).
 459
 460
 461 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
 462 reponses() ->
 463    F = fun() ->
 464       e(q([E || E <- mnesia:table(reponse_minichat)]))
 465    end,
 466    resultat_transaction(mnesia:transaction(F)).
 467
 468
 469 % Renvoie les messages auquel M_id répond.
 470 repond_a(M_id) ->
 471    resultat_transaction(mnesia:transaction(
 472       fun() ->
 473          e(q(
 474             [M || E <- mnesia:table(reponse_minichat),
 475             M <- mnesia:table(minichat),
 476             E#reponse_minichat.repondant =:= M_id,
 477             M#minichat.id =:= E#reponse_minichat.cible]))
 478       end
 479    )).
 480
 481
 482 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
 483 est_une_reponse_a_user(Id_user, Id_mess) ->
 484    case mnesia:transaction(
 485             fun() ->
 486                e(q([
 487                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 488                   M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
 489                ]), [{unique_all, true}])
 490             end
 491          ) of
 492       {atomic, [_]} -> true;
 493       _ -> false
 494    end.
 495
 496
 497 % Est-ce que Id_user à répondu au message Id_mess
 498 a_repondu_a_message(Id_user, Id_mess) ->
 499    case mnesia:transaction(
 500             fun() ->
 501                e(q([
 502                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 503                   R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
 504                ]), [{unique_all, true}])
 505             end
 506          ) of
 507       {atomic, [_]} -> true;
 508       _ -> false
 509    end.
 510
 511
 512 % Est-ce que Id_user possède Id_mess ?
 513 possede_message(Id_user, Id_mess) ->
 514    case mnesia:transaction(
 515             fun() ->
 516                e(q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]))
 517             end
 518          ) of
 519       {atomic, [Id_user | []]} -> true;
 520       _ -> false
 521    end.
 522
 523
 524 ip_table() ->
 525    resultat_transaction(mnesia:transaction(
 526       fun() ->
 527          e(q([IP || IP <- mnesia:table(ip_table)]))
 528       end
 529    )).
 530
 531
 532 % Bannie une ip pour un certain temps (en minute).
 533 ban(IP, Duration) ->
 534    mnesia:transaction(
 535       fun() ->
 536          case mnesia:wread({ip_table, IP}) of
 537             [IP_tuple] ->
 538                mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
 539             _ ->
 540                mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
 541           end
 542       end
 543    ).
 544
 545
 546 % Débanni une ip
 547 deban(IP) ->
 548    ban(IP, 0).
 549
 550
 551 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
 552 % ou false.
 553 est_banni(User_id) ->
 554    resultat_transaction(mnesia:transaction(
 555       fun() ->
 556          case e(q([
 557             {IP#ip_table.ban, IP#ip_table.ban_duration} ||
 558             U <- mnesia:table(user),
 559             U#user.id =:= User_id,
 560             IP <- mnesia:table(ip_table),
 561             IP#ip_table.ip =:= U#user.last_ip
 562          ])) of
 563             [{Ban, Ban_duration}] ->
 564                Echeance = date_plus_minutes(Ban, Ban_duration),
 565                Now = now(),
 566                if Echeance < Now -> % l'échéance est passée
 567                      false;
 568                   true ->
 569                      {true, trunc(delta_date_ms(Echeance, Now) / 1000 / 60)}
 570                end;
 571             _ ->
 572                false
 573          end
 574       end
 575    )).
 576
 577
 578 % Ban est une date tel que retourner par now().
 579 % Ban_duration est un temps en minutes.
 580 % retourne une date.
 581 date_plus_minutes(Ban, Ban_duration) ->
 582    Duration_sec = Ban_duration * 60,
 583    {MegaSec, Sec, MicroSec} = Ban,
 584    {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
 585
 586
 587 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
 588 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
 589 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
 590 can_register(IP) ->
 591    resultat_transaction(mnesia:transaction(
 592       fun() ->
 593          case e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP])) of
 594             [] ->
 595                mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
 596                true;
 597             [T] ->
 598                Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
 599                if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
 600                      false;
 601                   true ->
 602                      mnesia:write(#ip_table{
 603                         ip = IP,
 604                         date_last_try_register = now(),
 605                         nb_try_register = T#ip_table.nb_try_register + if Delta < ?TEMPS_FLOOD_REGISTER -> 1; T#ip_table.nb_try_register > 0 -> -1; true -> 0 end
 606                      }),
 607                      true
 608                end
 609          end
 610       end
 611    )).
 612
 613
 614 % Renvoie tous les trolls
 615 trolls() ->
 616    resultat_transaction(mnesia:transaction(
 617       fun() ->
 618          e(q([T || T <- qlc:keysort(2, mnesia:table(troll))]))
 619       end
 620    )).
 621
 622
 623 % Renvoie les trolls manquants posté après Last_id.
 624 trolls(Last_id) ->
 625    resultat_transaction(mnesia:transaction(
 626       e(q([T || T <- qlc:keysort(2, mnesia:table(troll)), T#troll.id > Last_id, T#troll.date_post =:= undefined]))
 627    )).
 628
 629
 630 % Renvoie les trolls manquants posté après Last_id.
 631 % Si pas de trolls alors attend un événement tel qu'un ajout, une modification ou une suppression.
 632 % renvoie :
 633 %  {mod, Troll}
 634 % ou {add, [Trolls]}
 635 % ou {del, Troll_id}
 636 % ou timeout
 637 trolls_attente(Last_id) ->
 638    case mnesia:subscribe({table, troll, detailed}) of
 639       {error, E} = E ->
 640          E;
 641       _ ->
 642          R = case resultat_transaction(mnesia:transaction(
 643                fun() ->
 644                   e(q([T || T <- qlc:keysort(2, mnesia:table(troll)), T#troll.id > Last_id, T#troll.date_post =:= undefined]))
 645                end
 646             )) of
 647                [] -> % pas de trolls
 648                   attend_evenement_troll();
 649                Trolls ->
 650                   {add, Trolls}
 651          end,
 652          mnesia:unsubscribe({table, troll, detailed}),
 653          R
 654    end.
 655
 656 attend_evenement_troll() ->
 657    % s'il n'y a pas de trolls que l'utilisateur n'a pas connaissance alors on attend un événement
 658    receive
 659       % cas où un troll est choisit comme courant
 660       {mnesia_table_event, {write, troll, Troll, [Old_troll | _], _}} when Old_troll#troll.date_post =:= undefined, Troll#troll.date_post =/= undefined ->
 661          {del, Troll#troll.id};
 662       {mnesia_table_event, {write, troll, Troll, [_Old_troll | _], _}} ->
 663          {mod, Troll};
 664       {mnesia_table_event, {write, troll, Troll, [], _}} ->
 665          {add, [Troll]};
 666       {mnesia_table_event, {delete, troll, {troll, Id}, _, _}} ->
 667          {del, Id};
 668       {tcp_closed, _} ->
 669          exit(normal);
 670       _ ->
 671          attend_evenement_troll()
 672    % 60 minutes de timeout (on ne sais jamais)
 673    % Après 60 minutes de connexion, le client doit donc reétablir une connexion
 674    after 1000 * 60 * 60 ->
 675       timeout
 676    end.
 677
 678
 679  % Renvoie l'id du nouveau troll
 680  % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind
 681  % ou max_troll_reached si le nombre de troll posté max a été atteind
 682  % ou user_unknown
 683 put_troll(User_id, Content) ->
 684    resultat_transaction(mnesia:transaction(
 685       fun() ->
 686          % control le nombre de troll déjà posté
 687          Nb_troll_poste_par_user = length(e(q(
 688             [
 689                E#troll.id || E <- mnesia:table(troll),
 690                E#troll.id_user =:= User_id,
 691                E#troll.date_post =:= undefined
 692             ]
 693          ))),
 694          Nb_troll_poste_total = length(e(q(
 695             [
 696                E#troll.id || E <- mnesia:table(troll),
 697                E#troll.date_post =:= undefined
 698             ]
 699          ))),
 700          User = user_by_id(User_id),
 701          case User of
 702             {ok, _} ->
 703                if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER ->
 704                      max_troll_reached_per_user;
 705                   Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING ->
 706                      max_troll_reached;
 707                   true ->
 708                      Id = nouvel_id(minichat),
 709                      mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}),
 710                      Id
 711                end;
 712             _ ->
 713                user_unknown
 714          end
 715       end
 716    )).
 717
 718
 719 % renvoie ok | erreur
 720 mod_troll(Troll_id, Content) ->
 721    mnesia:transaction(
 722       fun() ->
 723          case mnesia:wread({troll, Troll_id}) of
 724             [Troll = #troll{date_post = undefined}] ->
 725                mnesia:write(Troll#troll{content = Content});
 726             _ ->
 727                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 728           end
 729       end
 730    ).
 731
 732
 733 del_troll(Troll_id) ->
 734    mnesia:transaction(
 735       fun() ->
 736          case mnesia:wread({troll, Troll_id}) of
 737             [#troll{date_post = undefined}] ->
 738                mnesia:delete({troll, Troll_id});
 739             _ ->
 740                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 741           end
 742       end
 743    ).
 744
 745
 746 troll_by_id(Troll_id) ->
 747    resultat_transaction(mnesia:transaction(
 748       fun() ->
 749          case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id])) of
 750             [T] -> {ok, T};
 751             _ ->
 752                erreur
 753          end
 754       end
 755    )).
 756
 757
 758 % Renvoie le troll actuel qui se trouve sur la page principale.
 759 % Renvois aucun si pas de troll courant.
 760 current_troll() ->
 761    resultat_transaction(mnesia:transaction(
 762       fun() ->
 763          % TODO : ya pas moyen de désigner le champs plutot qu'avec un nombre pour le tri ?
 764          C = cursor(q([T || T <- qlc:keysort(5, mnesia:table(troll), [{order, descending}]), T#troll.date_post =/= undefined])),
 765          R = case qlc:next_answers(C, 1) of
 766             [T] -> T;
 767             _ -> aucun
 768          end,
 769          qlc:delete_cursor(C),
 770          R
 771       end
 772    )).
 773
 774
 775 % Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined)
 776 % met à jour sa date de post.
 777 % renvoie plus_de_trolls si il n'y a aucun troll en attente.
 778 elire_troll() ->
 779    {A1,A2,A3} = now(),
 780    random:seed(A1, A2, A3),
 781    mnesia:transaction(
 782       fun() ->
 783          case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined])) of
 784             [] ->
 785                plus_de_trolls;
 786             Trolls ->
 787                Troll = lists:nth(random:uniform(length(Trolls)), Trolls),
 788                Troll2 = Troll#troll{date_post = now()},
 789                mnesia:write(Troll2)
 790          end
 791       end
 792    ).
 793
 794
 795
 796 update_version(1) ->
 797    mnesia:transform_table(
 798       ip_table,
 799       fun() -> null end,
 800       record_info(fields, ip_table),
 801       ip_table
 802    ).
 803
 804
 805 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
 806 resultat_transaction({_, T}) ->
 807    T.
 808
 809
 810 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
 811 delta_date_ms(D1, D2) ->
 812    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).
 813
 814
 815 % Bizarre, cette fonction n'existe pas dans la stdlib.
 816 % Pas utilisé mais bon ca me fait de la peine de l'enlever.
 817 ceiling(X) ->
 818    T = trunc(X),
 819    case (X - T) of
 820       Neg when Neg < 0 -> T;
 821       Pos when Pos > 0 -> T + 1;
 822       _ -> T
 823    end.
 824
 825
 826 % Renvoie un nouvel id pour une table donnée
 827 nouvel_id(Table) ->
 828    mnesia:dirty_update_counter(counter, Table, 1).
 829