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          case mnesia:read({user,  ID}) of
 198             [User] -> {ok, User};
 199             _ -> erreur
 200          end
 201       end
 202    )).
 203
 204
 205 user_by_login(Login) ->
 206    resultat_transaction(mnesia:transaction(
 207       fun() ->
 208          Users = e(q([E || E <- mnesia:table(user), E#user.login =:= Login]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]),
 209          case Users of
 210             [User] -> {ok, User};
 211             _ -> erreur
 212          end
 213       end
 214    )).
 215
 216
 217 % Renvoie une chaine représentant le cookie ou undefined si pas trouvé.
 218 css_from_user_cookie(Cookie) ->
 219    case user_by_cookie(Cookie) of
 220       {ok, #user{profile = Profile}} ->
 221          Profile#profile.css;
 222       _ ->
 223          undefined
 224    end.
 225
 226
 227 is_ek_master_from_cookie(Cookie) ->
 228    case user_by_cookie(Cookie) of
 229       {ok, #user{ek_master = true}} -> true;
 230       _ -> false
 231    end.
 232
 233
 234 user_by_login_password(Login, Password) ->
 235    resultat_transaction(mnesia:transaction(
 236       fun() ->
 237          case e(q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 238             [User | _] -> {ok, User};
 239             _ -> erreur
 240          end
 241       end
 242    )).
 243
 244
 245 % Renvoie {ok, User} où User est un #user possédant le message donné.
 246 user_by_mess(Id) ->
 247    resultat_transaction(mnesia:transaction(
 248       fun() ->
 249          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
 250             [User | _] -> {ok, User};
 251             _ -> erreur
 252          end
 253       end
 254    )).
 255
 256
 257 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
 258 % retourne soit l'id du message soit {erreur, <raison>}.
 259 nouveau_message(Mess, Auteur_id, Repond_A_ids) ->
 260    % regarde si les id 'Repond_A' existent
 261    F = fun() ->
 262       Repond_a = e(
 263          q([M || M <- mnesia:table(minichat), lists:member(M#minichat.id, Repond_A_ids)]),
 264          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 265       ),
 266       Racine_id = case Repond_a of
 267          [] -> undefined;
 268          [M | _ ] ->
 269             Une_racine = M#minichat.racine_id,
 270             % vérification que tout les messages de Repond_a possède la même racine (même conversation)
 271             case lists:all(fun(R) -> R#minichat.racine_id =:= Une_racine end, Repond_a) of
 272                true ->
 273                   Une_racine;
 274                _ ->
 275                   {erreur, "Les messages ne font pas partie de la même conversation"}
 276             end
 277       end,
 278       case Racine_id of
 279          {erreur, E} -> {erreur, E};
 280          _ ->
 281             % est-ce que l'auteur existe ?
 282             case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 283                [#user{profile = Profile} = Auteur] ->
 284                   if length(Repond_a) =/= length(Repond_A_ids) ->
 285                         {erreur, "Un ou plusieurs messages introuvable"};
 286                      true ->
 287                         % comparaison entre la date du dernier poste et maintenant (gestion du flood)
 288                         Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
 289                         Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
 290                         Auteur_maj = Auteur#user{
 291                            indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
 292                            date_derniere_connexion = now()
 293                         },
 294                         % est-ce que l'auteur à trop floodé ?
 295                         if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 296                            mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
 297                            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.");
 298                         Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 299                            {erreur, "Bloqué pour cause de flood"};
 300                         true ->
 301                            mnesia:write(Auteur_maj),
 302                            Id = nouvel_id(minichat),
 303                            inserer_reponses(Id, Repond_A_ids),
 304                            mnesia:write(#minichat{
 305                               id = Id,
 306                               auteur_id = Auteur#user.id,
 307                               date = now(),
 308                               pseudo = Profile#profile.pseudo,
 309                               contenu = Mess,
 310                               racine_id = if Racine_id =:= undefined -> Id; true -> Racine_id end
 311                            }),
 312                            Id
 313                         end
 314                   end;
 315                _ ->
 316                   {erreur, "L'auteur du message est introuvable"}
 317             end
 318       end
 319    end,
 320    resultat_transaction(mnesia:transaction(F)).
 321
 322 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
 323 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
 324    mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
 325    inserer_reponses(Id_repondant, Reste);
 326 inserer_reponses(_, []) ->
 327    ok.
 328
 329
 330 % Permet de créer un message système.
 331 % Renvoie l'id du message système
 332 nouveau_message_sys(Mess) ->
 333    nouveau_message_sys(Mess, undefined).
 334
 335
 336 % Création d'un message système lié à un troll.
 337 nouveau_message_sys(Mess, Troll_id) ->
 338    {ok, #user{profile = Profile}} = user_by_id(0),
 339    resultat_transaction(mnesia:transaction(
 340       fun() ->
 341          Id = nouvel_id(minichat),
 342          mnesia:write(#minichat{id = Id, auteur_id = 0, date = now(), pseudo = Profile#profile.pseudo, contenu = Mess, troll_id = Troll_id, racine_id = Id}),
 343          Id
 344       end
 345    )).
 346
 347
 348 % Renvoie N messages se trouvant sur la première page
 349 messages(N) ->
 350    messages(N, 1).
 351
 352
 353 % Renvoie N messages se trouvant sur la page P
 354 messages(N, P) ->
 355    F = fun() ->
 356       C = cursor(
 357          qlc:keysort(
 358             #minichat.id,
 359             q([E#minichat{contenu = contenu_message(E)} || E <- mnesia:table(minichat)]),
 360             [{order, descending}]
 361          ),
 362          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 363       ),
 364       if P > 1 -> qlc:next_answers(C, N * (P - 1));
 365          true -> ok
 366       end,
 367       R = qlc:next_answers(C, N),
 368       qlc:delete_cursor(C),
 369       R
 370    end,
 371    lists:reverse(resultat_transaction(mnesia:transaction(F))).
 372
 373
 374 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
 375 % par page et que le dernier message que l'on possède est Id
 376 messages(Id, N, P) ->
 377    lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
 378
 379
 380 % Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
 381 message_by_id(Id) ->
 382    resultat_transaction(mnesia:transaction(
 383       fun() ->
 384          case mnesia:read({minichat, Id}) of
 385             [M] -> {ok, M#minichat{contenu = contenu_message(M)}};
 386             _ -> erreur
 387          end
 388       end
 389    )).
 390
 391
 392 % Renvoie le contenu d'un message donnée en fonction du troll associé, à utiliser à l'intérieur d'une transaction.
 393 % TODO : Cette fonction pourrait être remplacé par un "outer-join", est-ce possible avec qlc ?
 394 contenu_message(E) ->
 395    case mnesia:read({troll, E#minichat.troll_id}) of
 396       [] -> E#minichat.contenu;
 397       [T] -> E#minichat.contenu ++ T#troll.content
 398    end.
 399
 400
 401 % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
 402 % TODO : optimisations ? serait-ce du O(n) ?
 403 % Bon de toutes façons on s'en fout c'est pas utilisé :)
 404 messages_by_ids(Ids) ->
 405    resultat_transaction(mnesia:transaction(
 406       fun() ->
 407          e(qlc:keysort(
 408             #minichat.id,
 409             q([E || E <- mnesia:table(minichat), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
 410             [{order, ascending}]
 411          ),[{tmpdir, ?KEY_SORT_TEMP_DIR}])
 412       end
 413    )).
 414
 415
 416 % Est-ce qu'un message existe ? Renvoie un boolean.
 417 % TODO : ya pas plus simple ?
 418 message_existe(Id) ->
 419    resultat_transaction(mnesia:transaction(fun() ->
 420       length(e(q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])) =:= 1
 421    end)).
 422
 423
 424 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
 425 reponses() ->
 426    F = fun() ->
 427       e(q([E || E <- mnesia:table(reponse_minichat)]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 428    end,
 429    resultat_transaction(mnesia:transaction(F)).
 430
 431
 432 % Renvoie les messages auquel M_id répond.
 433 parents(M_id) ->
 434    resultat_transaction(mnesia:transaction(
 435       fun() ->
 436          e(q(
 437             [M || R <- mnesia:table(reponse_minichat),
 438             M <- mnesia:table(minichat),
 439             R#reponse_minichat.repondant =:= M_id,
 440             M#minichat.id =:= R#reponse_minichat.cible]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 441       end
 442    )).
 443
 444
 445 % Renvoie les message qui repondent à M_id
 446 enfants(M_id) ->
 447    resultat_transaction(mnesia:transaction(
 448       fun() ->
 449          e(q(
 450             [M || R <- mnesia:table(reponse_minichat),
 451             M <- mnesia:table(minichat),
 452             R#reponse_minichat.cible =:= M_id,
 453             M#minichat.id =:= R#reponse_minichat.repondant]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 454       end
 455    )).
 456
 457
 458 % Renvoie les id des parents d'un message M (les messages auquels répond M)
 459 % ordrés du plus petit au plus grand..
 460 % On évite d'utiliser qlc pour des raisons de performance
 461 % @spec parents_id(integer()) -> [integer()]
 462 parents_id(M_id) ->
 463    resultat_transaction(mnesia:transaction(fun() ->
 464       case mnesia:read({reponse_minichat, M_id}) of
 465          Parents when is_list(Parents) ->
 466             lists:sort(lists:map(
 467                fun(#reponse_minichat{cible = Cible}) -> Cible end,
 468                Parents
 469             ));
 470          _ -> []
 471       end
 472    end)).
 473
 474
 475 % Renvoie les id des enfants d'un message M (les messages qui répondent à M)
 476 % ordrés du plus petit au plus grand.
 477 % @spec enfants_id(integer()) -> [integer()]
 478 enfants_id(M) ->
 479    resultat_transaction(mnesia:transaction(fun() ->
 480       e(
 481          qlc:sort(
 482             q([E#reponse_minichat.repondant || E <- mnesia:table(reponse_minichat), E#reponse_minichat.cible =:= M]),
 483             [{order, ascending}]
 484          ),
 485          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 486       )
 487    end)).
 488
 489
 490 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
 491 % On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance.
 492 est_une_reponse_a_user(Id_user, Id_mess) ->
 493    resultat_transaction(mnesia:transaction(
 494       fun() ->
 495          case mnesia:read({reponse_minichat, Id_mess}) of
 496             [] -> false;
 497             Cibles ->
 498                lists:any(
 499                   fun(#reponse_minichat{cible = Cible}) ->
 500                      case mnesia:read({minichat, Cible}) of
 501                         [#minichat{auteur_id = Id_user}] -> true;
 502                         _ -> false
 503                      end
 504                   end,
 505                   Cibles
 506                )
 507          end
 508       end
 509    )).
 510
 511
 512 % Est-ce que Id_user à répondu au message Id_mess
 513 % On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance.
 514 a_repondu_a_message(Id_user, Id_mess) ->
 515    resultat_transaction(mnesia:transaction(
 516       fun() ->
 517          case mnesia:match_object({reponse_minichat, '_', Id_mess}) of
 518             [] -> false;
 519             Reponses ->
 520                lists:any(
 521                   fun(#reponse_minichat{repondant = Reponse}) ->
 522                      case mnesia:read({minichat, Reponse}) of
 523                         [#minichat{auteur_id = Id_user}] -> true;
 524                         _ -> false
 525                      end
 526                   end,
 527                   Reponses
 528                )
 529          end
 530       end
 531    )).
 532
 533
 534 % Est-ce que Id_user possède Id_mess ?
 535 possede_message(Id_user, Id_mess) ->
 536    case mnesia:transaction(
 537             fun() ->
 538                e(q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 539             end
 540          ) of
 541       {atomic, [Id_user | []]} -> true;
 542       _ -> false
 543    end.
 544
 545
 546 % renvoie la liste des ip bannies
 547 % liste de {ip, temps_restant(en minutes), Users} ou Users est une liste de {pseudo, login}
 548 % TODO : déterminer la complexité de cette fonction. (Il n'y a pas d'index sur #user.last_ip)
 549 list_ban() ->
 550    resultat_transaction(mnesia:transaction(
 551       fun() ->
 552          Now = now(),
 553          e(qlc:keysort(1, q([
 554             {
 555                IP#ip_table.ip,
 556                delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now),
 557                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}])
 558             } ||
 559             IP <- mnesia:table(ip_table),
 560             if IP#ip_table.ban =:= undefined -> false; true -> date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration) > Now end
 561          ])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 562       end
 563    )).
 564
 565
 566 % Bannie une ip pour un certain temps (en minute).
 567 ban(IP, Duration) ->
 568    mnesia:transaction(
 569       fun() ->
 570          case mnesia:wread({ip_table, IP}) of
 571             [IP_tuple] ->
 572                mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
 573             _ ->
 574                mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
 575           end
 576       end
 577    ).
 578
 579
 580 % Débanni une ip
 581 deban(IP) ->
 582    ban(IP, 0).
 583
 584
 585 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
 586 % ou false.
 587 est_banni(User_id) ->
 588    resultat_transaction(mnesia:transaction(
 589       fun() ->
 590          case e(q([
 591             {IP#ip_table.ban, IP#ip_table.ban_duration} ||
 592             U <- mnesia:table(user),
 593             U#user.id =:= User_id,
 594             IP <- mnesia:table(ip_table),
 595             IP#ip_table.ip =:= U#user.last_ip
 596          ]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 597             [{Ban, Ban_duration}] ->
 598                Echeance = date_plus_minutes(Ban, Ban_duration),
 599                Now = now(),
 600                if Echeance < Now -> % l'échéance est passée
 601                      false;
 602                   true ->
 603                      {true, delta_date_minute(Echeance, Now)}
 604                end;
 605             _ ->
 606                false
 607          end
 608       end
 609    )).
 610
 611
 612 % Ban est une date tel que retourner par now().
 613 % Ban_duration est un temps en minutes.
 614 % retourne une date.
 615 date_plus_minutes(Ban, Ban_duration) ->
 616    Duration_sec = Ban_duration * 60,
 617    {MegaSec, Sec, MicroSec} = Ban,
 618    {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
 619
 620
 621 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
 622 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
 623 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
 624 can_register(IP) ->
 625    resultat_transaction(mnesia:transaction(
 626       fun() ->
 627          case e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 628             [] ->
 629                mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
 630                true;
 631             [T] ->
 632                Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
 633                if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
 634                      false;
 635                   true ->
 636                      mnesia:write(#ip_table{
 637                         ip = IP,
 638                         date_last_try_register = now(),
 639                         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
 640                      }),
 641                      true
 642                end
 643          end
 644       end
 645    )).
 646
 647
 648 % Renvoie tous les trolls
 649 trolls() ->
 650    resultat_transaction(mnesia:transaction(
 651       fun() ->
 652          e(qlc:keysort(#troll.id, q([T || T <- mnesia:table(troll)])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 653       end
 654    )).
 655
 656
 657 % Renvoie les trolls manquants posté après Last_id.
 658 trolls(Last_id) ->
 659    resultat_transaction(mnesia:transaction(
 660       fun() ->
 661          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}])
 662       end
 663    )).
 664
 665
 666  % Crée un nouveau troll.
 667  % Renvoie l'id du nouveau troll
 668  % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind
 669  % ou max_troll_reached si le nombre de troll posté max a été atteind
 670  % ou user_unknown
 671 put_troll(User_id, Content) ->
 672    resultat_transaction(mnesia:transaction(
 673       fun() ->
 674          % control le nombre de troll déjà posté
 675          Nb_troll_poste_par_user = length(e(q(
 676             [
 677                E#troll.id || E <- mnesia:table(troll),
 678                E#troll.id_user =:= User_id,
 679                E#troll.date_post =:= undefined
 680             ]
 681          ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])),
 682          Nb_troll_poste_total = length(e(q(
 683             [
 684                E#troll.id || E <- mnesia:table(troll),
 685                E#troll.date_post =:= undefined
 686             ]
 687          ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])),
 688          User = user_by_id(User_id),
 689          case User of
 690             {ok, _} ->
 691                if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER ->
 692                      max_troll_reached_per_user;
 693                   Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING ->
 694                      max_troll_reached;
 695                   true ->
 696                      Id = nouvel_id(minichat),
 697                      mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}),
 698                      Id
 699                end;
 700             _ ->
 701                user_unknown
 702          end
 703       end
 704    )).
 705
 706
 707 % renvoie ok | erreur
 708 mod_troll(Troll_id, Content) ->
 709    mnesia:transaction(
 710       fun() ->
 711          case mnesia:wread({troll, Troll_id}) of
 712             [Troll = #troll{date_post = undefined}] ->
 713                mnesia:write(Troll#troll{content = Content});
 714             _ ->
 715                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 716           end
 717       end
 718    ).
 719
 720
 721 del_troll(Troll_id) ->
 722    mnesia:transaction(
 723       fun() ->
 724          case mnesia:wread({troll, Troll_id}) of
 725             [#troll{date_post = undefined}] ->
 726                mnesia:delete({troll, Troll_id});
 727             _ ->
 728                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 729           end
 730       end
 731    ).
 732
 733
 734 troll_by_id(Troll_id) ->
 735    resultat_transaction(mnesia:transaction(
 736       fun() ->
 737          case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 738             [T] -> {ok, T};
 739             _ ->
 740                erreur
 741          end
 742       end
 743    )).
 744
 745
 746 % Renvoie le troll actuel qui se trouve sur la page principale.
 747 % Renvois aucun si pas de troll courant.
 748 current_troll() ->
 749    resultat_transaction(mnesia:transaction(
 750       fun() ->
 751          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}]),
 752          R = case qlc:next_answers(C, 1) of
 753             [T] -> T;
 754             _ -> aucun
 755          end,
 756          qlc:delete_cursor(C),
 757          R
 758       end
 759    )).
 760
 761
 762 % Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined)
 763 % Un message est posté par 'Sys' et le troll elu est lié à ce message
 764 % met à jour sa date de post.
 765 % renvoie plus_de_trolls si il n'y a aucun troll en attente.
 766 elire_troll() ->
 767    {A1,A2,A3} = now(),
 768    random:seed(A1, A2, A3),
 769    mnesia:transaction(
 770       fun() ->
 771          case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 772             [] ->
 773                plus_de_trolls;
 774             Trolls ->
 775                Troll = lists:nth(random:uniform(length(Trolls)), Trolls),
 776                Troll2 = Troll#troll{date_post = now()},
 777                mnesia:write(Troll2),
 778                nouveau_message_sys("Troll de la semaine : ", Troll2#troll.id)
 779          end
 780       end
 781    ).
 782
 783
 784 % Renvoie l'id du message associé au troll dont l'id est donnée.
 785 % Renvoie undefined si il n'y en a pas.
 786 message_id_associe(Troll_id) ->
 787    resultat_transaction(mnesia:transaction(
 788       fun() ->
 789          case e(q([M#minichat.id || M <- mnesia:table(minichat), M#minichat.troll_id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 790             [Id] -> Id;
 791             _ -> undefined
 792          end
 793       end
 794    )).
 795
 796
 797 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
 798 resultat_transaction({_, T}) ->
 799    T.
 800
 801
 802 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
 803 delta_date_ms(D1, D2) ->
 804    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).
 805
 806 % Retourne la différence entre deux timestamp (erlang:now) en minutes
 807 delta_date_minute(D1, D2) ->
 808    trunc(delta_date_ms(D1, D2) / 1000 / 60).
 809
 810
 811 % Renvoie un nouvel id pour une table donnée
 812 nouvel_id(Table) ->
 813    mnesia:dirty_update_counter(counter, Table, 1).
 814