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