modules/erl/euphorik_bd.erl

   1 % coding: utf-8
   2 % Copyright 2008 Grégory Burri
   3 %
   4 % This file is part of Euphorik.
   5 %
   6 % Euphorik is free software: you can redistribute it and/or modify
   7 % it under the terms of the GNU General Public License as published by
   8 % the Free Software Foundation, either version 3 of the License, or
   9 % (at your option) any later version.
  10 %
  11 % Euphorik is distributed in the hope that it will be useful,
  12 % but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 % MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 % GNU General Public License for more details.
  15 %
  16 % You should have received a copy of the GNU General Public License
  17 % along with Euphorik.  If not, see <http://www.gnu.org/licenses/>.
  18 %
  19 % Ce module permet de gérer les données persistantes lié au site d'euphorik.ch.
  20 % Il permet d'ajouter des message, de demande les messages sur une page donnée, etc..
  21 % Ce module utilise une base mnesia.
  22 % @author G.Burri
  23
  24
  25 -module(euphorik_bd).
  26 -export([
  27    % users :
  28    nouveau_user/2,
  29    nouveau_user/4,
  30    set_profile/4,
  31    update_date_derniere_connexion/1,
  32    update_ip/2,
  33    update_pseudo_user/2,
  34    user_by_cookie/1,
  35    user_by_id/1,
  36    user_by_login/1,
  37    user_by_login_password/2,
  38    user_by_mess/1,
  39    css_from_user_cookie/1,
  40    is_ek_master_from_cookie/1,
  41
  42    % messages :e
  43    nouveau_message/3,
  44    nouveau_message_sys/1,
  45    nouveau_message_sys/2,
  46    messages/1,
  47    messages/2,
  48    messages/3,
  49    message_by_id/1,
  50    messages_by_ids/1,
  51    message_existe/1,
  52    reponses/0,
  53    parents/1,
  54    enfants/1,
  55    parents_id/1,
  56    enfants_id/1,
  57    est_une_reponse_a_user/2,
  58    a_repondu_a_message/2,
  59    possede_message/2,
  60
  61    % ip :
  62    list_ban/0,
  63    ban/2,
  64    deban/1,
  65    est_banni/1,
  66    can_register/1,
  67
  68    % trolls :
  69    trolls/0,
  70    trolls/1,
  71    put_troll/2,
  72    mod_troll/2,
  73    del_troll/1,
  74    troll_by_id/1,
  75    current_troll/0,
  76    elire_troll/0,
  77    message_id_associe/1,
  78
  79    % utiles :
  80    resultat_transaction/1
  81 ]).
  82 -import(qlc, [e/2, q/1, cursor/2]).
  83 -include("../include/euphorik_bd.hrl").
  84 -include("../include/euphorik_defines.hrl").
  85 -include_lib("stdlib/include/qlc.hrl").
  86
  87
  88 % Ajoute un nouveau user et le renvoie
  89 nouveau_user(Cookie, Profile) ->
  90    F = fun() ->
  91       Id = nouvel_id(user),
  92       User = #user{id = Id, cookie = Cookie, date_creation = now(), date_derniere_connexion = now(), profile = Profile},
  93       mnesia:write(User),
  94       User
  95    end,
  96   resultat_transaction(mnesia:transaction(F)).
  97
  98
  99 % Ajoute un nouveau user et le renvoie
 100 nouveau_user(Login, Password, Cookie, Profile) ->
 101    F = fun() ->
 102       Id = nouvel_id(user),
 103       User = #user{id = Id, cookie = Cookie, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now(), profile = Profile#profile{pseudo = Login}},
 104       mnesia:write(User),
 105       User
 106    end,
 107   resultat_transaction(mnesia:transaction(F)).
 108
 109
 110 % Définit les données du profile d'une utilisateur.
 111 set_profile(Cookie, Login, Password, Profile) ->
 112    resultat_transaction(mnesia:transaction(
 113       fun() ->
 114          case user_by_cookie(Cookie) of
 115             {ok, User_existant} ->
 116                case user_by_login(Login) of
 117                   {ok, U} when Login =/= [], U#user.id =/= User_existant#user.id ->
 118                      login_deja_pris;
 119                   _ ->
 120                      mnesia:write(
 121                         User_existant#user{
 122                            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 !
 123                            password = if Password =:= [] -> User_existant#user.password; true -> Password end,
 124                            profile = Profile
 125                         }
 126                      ),
 127                      ok
 128                end;
 129             _ -> erreur
 130          end
 131       end
 132    )).
 133
 134
 135 % Met à jour la date de la dernière connexion d'un utilisateur à maintenant
 136 update_date_derniere_connexion(User_id) ->
 137    mnesia:transaction(
 138       fun() ->
 139          case mnesia:wread({user, User_id}) of
 140             [User] ->
 141                mnesia:write(User#user{date_derniere_connexion = now()});
 142             _ ->
 143                mnesia:abort("update_date_derniere_connexion: User inconnu")
 144           end
 145       end
 146    ).
 147
 148
 149 % Met à jour l'ip d'un user
 150 update_ip(User_id, IP) ->
 151    mnesia:transaction(
 152       fun() ->
 153          case mnesia:wread({user, User_id}) of
 154             [User] ->
 155                mnesia:write(User#user{last_ip = IP});
 156             _ ->
 157                mnesia:abort("update_ip: User inconnu")
 158           end
 159       end
 160    ).
 161
 162
 163 % Met à jour le pseudo du user
 164 update_pseudo_user(UserId, Pseudo) ->
 165    mnesia:transaction(
 166       fun() ->
 167          case mnesia:wread({user, UserId}) of
 168             [#user{profile = Profile} = User] when Profile#profile.pseudo =/= Pseudo ->
 169                mnesia:write(User#user{profile = Profile#profile { pseudo = Pseudo } });
 170             _ ->
 171                mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
 172           end
 173       end
 174    ).
 175
 176
 177 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
 178 % Renvoie {ok, User} ou erreur
 179 user_by_cookie(Cookie) ->
 180    resultat_transaction(mnesia:transaction(
 181       fun() ->
 182          case e(q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 183             [User] -> {ok, User};
 184             _ -> erreur
 185          end
 186       end
 187    )).
 188
 189
 190 user_by_id(ID) ->
 191    resultat_transaction(mnesia:transaction(
 192       fun() ->
 193          case e(q([E || E <- mnesia:table(user), E#user.id =:= ID]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 194             [User] -> {ok, User};
 195             _ -> erreur
 196          end
 197       end
 198    )).
 199
 200
 201 user_by_login(Login) ->
 202    resultat_transaction(mnesia:transaction(
 203       fun() ->
 204          Users = e(q([E || E <- mnesia:table(user), E#user.login =:= Login]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]),
 205          case Users of
 206             [User] -> {ok, User};
 207             _ -> erreur
 208          end
 209       end
 210    )).
 211
 212
 213 % Renvoie une chaine représentant le cookie ou undefined si pas trouvé.
 214 css_from_user_cookie(Cookie) ->
 215    case user_by_cookie(Cookie) of
 216       {ok, #user{profile = Profile}} ->
 217          Profile#profile.css;
 218       _ ->
 219          undefined
 220    end.
 221
 222
 223 is_ek_master_from_cookie(Cookie) ->
 224    case user_by_cookie(Cookie) of
 225       {ok, #user{ek_master = true}} -> true;
 226       _ -> false
 227    end.
 228
 229
 230 user_by_login_password(Login, Password) ->
 231    resultat_transaction(mnesia:transaction(
 232       fun() ->
 233          case e(q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 234             [User | _] -> {ok, User};
 235             _ -> erreur
 236          end
 237       end
 238    )).
 239
 240
 241 % Renvoie {ok, User} où User est un #user possédant le message donné.
 242 user_by_mess(Id) ->
 243    resultat_transaction(mnesia:transaction(
 244       fun() ->
 245          case e(q([U || U <- mnesia:table(user), M <- mnesia:table(minichat), M#minichat.id =:= Id, M#minichat.auteur_id =:= U#user.id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 246             [User | _] -> {ok, User};
 247             _ -> erreur
 248          end
 249       end
 250    )).
 251
 252
 253 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
 254 % retourne soit l'id du message soit {erreur, <raison>}.
 255 nouveau_message(Mess, Auteur_id, Repond_A_ids) ->
 256    % regarde si les id 'Repond_A' existent
 257    F = fun() ->
 258       Repond_a = e(
 259          q([M || M <- mnesia:table(minichat), lists:member(M#minichat.id, Repond_A_ids)]),
 260          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 261       ),
 262       Racine_id = case Repond_a of
 263          [] -> undefined;
 264          [M | _ ] ->
 265             Une_racine = M#minichat.racine_id,
 266             % vérification que tout les messages de Repond_a possède la même racine (même conversation)
 267             case lists:all(fun(R) -> R#minichat.racine_id =:= Une_racine end, Repond_a) of
 268                true ->
 269                   Une_racine;
 270                _ ->
 271                   {erreur, "Les messages ne font pas partie de la même conversation"}
 272             end
 273       end,
 274       case Racine_id of
 275          {erreur, E} -> {erreur, E};
 276          _ ->
 277             % est-ce que l'auteur existe ?
 278             case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 279                [#user{profile = Profile} = Auteur] ->
 280                   if length(Repond_a) =/= length(Repond_A_ids) ->
 281                         {erreur, "Un ou plusieurs messages introuvable"};
 282                      true ->
 283                         % comparaison entre la date du dernier poste et maintenant (gestion du flood)
 284                         Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
 285                         Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
 286                         Auteur_maj = Auteur#user{
 287                            indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
 288                            date_derniere_connexion = now()
 289                         },
 290                         % est-ce que l'auteur à trop floodé ?
 291                         if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 292                            mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
 293                            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.");
 294                         Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 295                            {erreur, "Bloqué pour cause de flood"};
 296                         true ->
 297                            mnesia:write(Auteur_maj),
 298                            Id = nouvel_id(minichat),
 299                            inserer_reponses(Id, Repond_A_ids),
 300                            mnesia:write(#minichat{
 301                               id = Id,
 302                               auteur_id = Auteur#user.id,
 303                               date = now(),
 304                               pseudo = Profile#profile.pseudo,
 305                               contenu = Mess,
 306                               racine_id = if Racine_id =:= undefined -> Id; true -> Racine_id end
 307                            }),
 308                            Id
 309                         end
 310                   end;
 311                _ ->
 312                   {erreur, "L'auteur du message est introuvable"}
 313             end
 314       end
 315    end,
 316    resultat_transaction(mnesia:transaction(F)).
 317
 318 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
 319 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
 320    mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
 321    inserer_reponses(Id_repondant, Reste);
 322 inserer_reponses(_, []) ->
 323    ok.
 324
 325
 326 % Permet de créer un message système.
 327 % Renvoie l'id du message système
 328 nouveau_message_sys(Mess) ->
 329    nouveau_message_sys(Mess, undefined).
 330
 331
 332 % Création d'un message système lié à un troll.
 333 nouveau_message_sys(Mess, Troll_id) ->
 334    {ok, #user{profile = Profile}} = user_by_id(0),
 335    resultat_transaction(mnesia:transaction(
 336       fun() ->
 337          Id = nouvel_id(minichat),
 338          mnesia:write(#minichat{id = Id, auteur_id = 0, date = now(), pseudo = Profile#profile.pseudo, contenu = Mess, troll_id = Troll_id, racine_id = Id}),
 339          Id
 340       end
 341    )).
 342
 343
 344 % Renvoie N messages se trouvant sur la première page
 345 messages(N) ->
 346    messages(N, 1).
 347
 348
 349 % Renvoie N messages se trouvant sur la page P
 350 messages(N, P) ->
 351    F = fun() ->
 352       C = cursor(
 353          qlc:keysort(
 354             #minichat.id,
 355             q([E#minichat{contenu = contenu_message(E)} || E <- mnesia:table(minichat)]),
 356             [{order, descending}]
 357          ),
 358          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 359       ),
 360       if P > 1 -> qlc:next_answers(C, N * (P - 1));
 361          true -> ok
 362       end,
 363       R = qlc:next_answers(C, N),
 364       qlc:delete_cursor(C),
 365       R
 366    end,
 367    lists:reverse(resultat_transaction(mnesia:transaction(F))).
 368
 369
 370 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
 371 % par page et que le dernier message que l'on possède est Id
 372 messages(Id, N, P) ->
 373    lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
 374
 375
 376 % Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
 377 message_by_id(Id) ->
 378    resultat_transaction(mnesia:transaction(
 379       fun() ->
 380          case mnesia:read({minichat, Id}) of
 381             [] -> erreur;
 382             [M] ->
 383                {ok, M#minichat{contenu = contenu_message(M)}}
 384          end
 385       end
 386    )).
 387
 388
 389 % Renvoie le contenu d'un message donnée, à utiliser à l'intérieur d'une transaction.
 390 % TODO : Cette fonction pourrait être remplacé par un "outer-join", est-ce possible avec qlc ?
 391 contenu_message(E) ->
 392    case mnesia:read({troll, E#minichat.troll_id}) of
 393       [] -> E#minichat.contenu;
 394       [T] -> E#minichat.contenu ++ T#troll.content
 395    end.
 396
 397
 398 % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
 399 % TODO : optimisations ? serait-ce du O(n) ?
 400 % Bon de toutes façons on s'en fout c'est pas utilisé :)
 401 messages_by_ids(Ids) ->
 402    resultat_transaction(mnesia:transaction(
 403       fun() ->
 404          e(qlc:keysort(
 405             #minichat.id,
 406             q([E || E <- mnesia:table(minichat), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
 407             [{order, ascending}]
 408          ),[{tmpdir, ?KEY_SORT_TEMP_DIR}])
 409       end
 410    )).
 411
 412
 413 % Est-ce qu'un message existe ? Renvoie un boolean.
 414 % TODO : ya pas plus simple ?
 415 message_existe(Id) ->
 416    resultat_transaction(mnesia:transaction(fun() ->
 417       length(e(q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])) =:= 1
 418    end)).
 419
 420
 421 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
 422 reponses() ->
 423    F = fun() ->
 424       e(q([E || E <- mnesia:table(reponse_minichat)]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 425    end,
 426    resultat_transaction(mnesia:transaction(F)).
 427
 428
 429 % Renvoie les messages auquel M_id répond.
 430 parents(M_id) ->
 431    resultat_transaction(mnesia:transaction(
 432       fun() ->
 433          e(q(
 434             [M || R <- mnesia:table(reponse_minichat),
 435             M <- mnesia:table(minichat),
 436             R#reponse_minichat.repondant =:= M_id,
 437             M#minichat.id =:= R#reponse_minichat.cible]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 438       end
 439    )).
 440
 441
 442 % Renvoie les message qui repondent à M_id
 443 enfants(M_id) ->
 444    resultat_transaction(mnesia:transaction(
 445       fun() ->
 446          e(q(
 447             [M || R <- mnesia:table(reponse_minichat),
 448             M <- mnesia:table(minichat),
 449             R#reponse_minichat.cible =:= M_id,
 450             M#minichat.id =:= R#reponse_minichat.repondant]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 451       end
 452    )).
 453
 454
 455 % Renvoie les parents d'un message M (les messages auquels répond M)
 456 % ordrés du plus petit au plus grand..
 457 % @spec parents_id(integer()) -> [integer()]
 458 parents_id(M) ->
 459    resultat_transaction(mnesia:transaction(fun() ->
 460       e(
 461          qlc:sort(
 462             q([E#reponse_minichat.cible || E <- mnesia:table(reponse_minichat), E#reponse_minichat.repondant =:= M]),
 463             [{order, ascending}]
 464          ),
 465          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 466       )
 467    end)).
 468
 469
 470 % Renvoie les id des enfants d'un message M (les messages qui répondent à M)
 471 % ordrés du plus petit au plus grand.
 472 % @spec enfants_id(integer()) -> [integer()]
 473 enfants_id(M) ->
 474    resultat_transaction(mnesia:transaction(fun() ->
 475       e(
 476          qlc:sort(
 477             q([E#reponse_minichat.repondant || E <- mnesia:table(reponse_minichat), E#reponse_minichat.cible =:= M]),
 478             [{order, ascending}]
 479          ),
 480          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 481       )
 482    end)).
 483
 484
 485 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
 486 est_une_reponse_a_user(Id_user, Id_mess) ->
 487    case mnesia:transaction(
 488             fun() ->
 489                e(q([
 490                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 491                   M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
 492                ]), [{unique_all, true}, {tmpdir, ?KEY_SORT_TEMP_DIR}])
 493             end
 494          ) of
 495       {atomic, [_]} -> true;
 496       _ -> false
 497    end.
 498
 499
 500 % Est-ce que Id_user à répondu au message Id_mess
 501 a_repondu_a_message(Id_user, Id_mess) ->
 502    case mnesia:transaction(
 503             fun() ->
 504                e(q([
 505                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 506                   R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
 507                ]), [{unique_all, true}, {tmpdir, ?KEY_SORT_TEMP_DIR}])
 508             end
 509          ) of
 510       {atomic, [_]} -> true;
 511       _ -> false
 512    end.
 513
 514
 515 % Est-ce que Id_user possède Id_mess ?
 516 possede_message(Id_user, Id_mess) ->
 517    case mnesia:transaction(
 518             fun() ->
 519                e(q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 520             end
 521          ) of
 522       {atomic, [Id_user | []]} -> true;
 523       _ -> false
 524    end.
 525
 526
 527 % renvoie la liste des ip bannies
 528 % liste de {ip, temps_restant(en minutes), Users} ou Users est une liste de {pseudo, login}
 529 % TODO : déterminer la complexité de cette fonction. (Il n'y a pas d'index sur #user.last_ip)
 530 list_ban() ->
 531    resultat_transaction(mnesia:transaction(
 532       fun() ->
 533          Now = now(),
 534          e(qlc:keysort(1, q([
 535             {
 536                IP#ip_table.ip,
 537                delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now),
 538                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}])
 539             } ||
 540             IP <- mnesia:table(ip_table),
 541             if IP#ip_table.ban =:= undefined -> false; true -> date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration) > Now end
 542          ])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 543       end
 544    )).
 545
 546
 547 % Bannie une ip pour un certain temps (en minute).
 548 ban(IP, Duration) ->
 549    mnesia:transaction(
 550       fun() ->
 551          case mnesia:wread({ip_table, IP}) of
 552             [IP_tuple] ->
 553                mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
 554             _ ->
 555                mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
 556           end
 557       end
 558    ).
 559
 560
 561 % Débanni une ip
 562 deban(IP) ->
 563    ban(IP, 0).
 564
 565
 566 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
 567 % ou false.
 568 est_banni(User_id) ->
 569    resultat_transaction(mnesia:transaction(
 570       fun() ->
 571          case e(q([
 572             {IP#ip_table.ban, IP#ip_table.ban_duration} ||
 573             U <- mnesia:table(user),
 574             U#user.id =:= User_id,
 575             IP <- mnesia:table(ip_table),
 576             IP#ip_table.ip =:= U#user.last_ip
 577          ]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 578             [{Ban, Ban_duration}] ->
 579                Echeance = date_plus_minutes(Ban, Ban_duration),
 580                Now = now(),
 581                if Echeance < Now -> % l'échéance est passée
 582                      false;
 583                   true ->
 584                      {true, delta_date_minute(Echeance, Now)}
 585                end;
 586             _ ->
 587                false
 588          end
 589       end
 590    )).
 591
 592
 593 % Ban est une date tel que retourner par now().
 594 % Ban_duration est un temps en minutes.
 595 % retourne une date.
 596 date_plus_minutes(Ban, Ban_duration) ->
 597    Duration_sec = Ban_duration * 60,
 598    {MegaSec, Sec, MicroSec} = Ban,
 599    {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
 600
 601
 602 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
 603 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
 604 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
 605 can_register(IP) ->
 606    resultat_transaction(mnesia:transaction(
 607       fun() ->
 608          case e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 609             [] ->
 610                mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
 611                true;
 612             [T] ->
 613                Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
 614                if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
 615                      false;
 616                   true ->
 617                      mnesia:write(#ip_table{
 618                         ip = IP,
 619                         date_last_try_register = now(),
 620                         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
 621                      }),
 622                      true
 623                end
 624          end
 625       end
 626    )).
 627
 628
 629 % Renvoie tous les trolls
 630 trolls() ->
 631    resultat_transaction(mnesia:transaction(
 632       fun() ->
 633          e(qlc:keysort(#troll.id, q([T || T <- mnesia:table(troll)])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 634       end
 635    )).
 636
 637
 638 % Renvoie les trolls manquants posté après Last_id.
 639 trolls(Last_id) ->
 640    resultat_transaction(mnesia:transaction(
 641       fun() ->
 642          e(qlc:keysort(#troll.id, q([T || T <- mnesia:table(troll), T#troll.id > Last_id, T#troll.date_post =:= undefined])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 643       end
 644    )).
 645
 646
 647  % Crée un nouveau troll.
 648  % Renvoie l'id du nouveau troll
 649  % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind
 650  % ou max_troll_reached si le nombre de troll posté max a été atteind
 651  % ou user_unknown
 652 put_troll(User_id, Content) ->
 653    resultat_transaction(mnesia:transaction(
 654       fun() ->
 655          % control le nombre de troll déjà posté
 656          Nb_troll_poste_par_user = length(e(q(
 657             [
 658                E#troll.id || E <- mnesia:table(troll),
 659                E#troll.id_user =:= User_id,
 660                E#troll.date_post =:= undefined
 661             ]
 662          ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])),
 663          Nb_troll_poste_total = length(e(q(
 664             [
 665                E#troll.id || E <- mnesia:table(troll),
 666                E#troll.date_post =:= undefined
 667             ]
 668          ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])),
 669          User = user_by_id(User_id),
 670          case User of
 671             {ok, _} ->
 672                if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER ->
 673                      max_troll_reached_per_user;
 674                   Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING ->
 675                      max_troll_reached;
 676                   true ->
 677                      Id = nouvel_id(minichat),
 678                      mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}),
 679                      Id
 680                end;
 681             _ ->
 682                user_unknown
 683          end
 684       end
 685    )).
 686
 687
 688 % renvoie ok | erreur
 689 mod_troll(Troll_id, Content) ->
 690    mnesia:transaction(
 691       fun() ->
 692          case mnesia:wread({troll, Troll_id}) of
 693             [Troll = #troll{date_post = undefined}] ->
 694                mnesia:write(Troll#troll{content = Content});
 695             _ ->
 696                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 697           end
 698       end
 699    ).
 700
 701
 702 del_troll(Troll_id) ->
 703    mnesia:transaction(
 704       fun() ->
 705          case mnesia:wread({troll, Troll_id}) of
 706             [#troll{date_post = undefined}] ->
 707                mnesia:delete({troll, Troll_id});
 708             _ ->
 709                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 710           end
 711       end
 712    ).
 713
 714
 715 troll_by_id(Troll_id) ->
 716    resultat_transaction(mnesia:transaction(
 717       fun() ->
 718          case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 719             [T] -> {ok, T};
 720             _ ->
 721                erreur
 722          end
 723       end
 724    )).
 725
 726
 727 % Renvoie le troll actuel qui se trouve sur la page principale.
 728 % Renvois aucun si pas de troll courant.
 729 current_troll() ->
 730    resultat_transaction(mnesia:transaction(
 731       fun() ->
 732          C = cursor(qlc:keysort(#troll.date_post, q([T || T <- mnesia:table(troll), T#troll.date_post =/= undefined]), [{order, descending}]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]),
 733          R = case qlc:next_answers(C, 1) of
 734             [T] -> T;
 735             _ -> aucun
 736          end,
 737          qlc:delete_cursor(C),
 738          R
 739       end
 740    )).
 741
 742
 743 % Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined)
 744 % Un message est posté par 'Sys' et le troll elu est lié à ce message
 745 % met à jour sa date de post.
 746 % renvoie plus_de_trolls si il n'y a aucun troll en attente.
 747 elire_troll() ->
 748    {A1,A2,A3} = now(),
 749    random:seed(A1, A2, A3),
 750    mnesia:transaction(
 751       fun() ->
 752          case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 753             [] ->
 754                plus_de_trolls;
 755             Trolls ->
 756                Troll = lists:nth(random:uniform(length(Trolls)), Trolls),
 757                Troll2 = Troll#troll{date_post = now()},
 758                mnesia:write(Troll2),
 759                nouveau_message_sys("Troll de la semaine : ", Troll2#troll.id)
 760          end
 761       end
 762    ).
 763
 764
 765 % Renvoie l'id du message associé au troll dont l'id est donnée.
 766 % Renvoie undefined si il n'y en a pas.
 767 message_id_associe(Troll_id) ->
 768    resultat_transaction(mnesia:transaction(
 769       fun() ->
 770          case e(q([M#minichat.id || M <- mnesia:table(minichat), M#minichat.troll_id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 771             [Id] -> Id;
 772             _ -> undefined
 773          end
 774       end
 775    )).
 776
 777
 778 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
 779 resultat_transaction({_, T}) ->
 780    T.
 781
 782
 783 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
 784 delta_date_ms(D1, D2) ->
 785    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).
 786
 787 % Retourne la différence entre deux timestamp (erlang:now) en minutes
 788 delta_date_minute(D1, D2) ->
 789    trunc(delta_date_ms(D1, D2) / 1000 / 60).
 790
 791
 792 % Renvoie un nouvel id pour une table donnée
 793 nouvel_id(Table) ->
 794    mnesia:dirty_update_counter(counter, Table, 1).
 795