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