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 parents d'un message M (les messages auquels répond M)
 459 % ordrés du plus petit au plus grand..
 460 % @spec parents_id(integer()) -> [integer()]
 461 parents_id(M) ->
 462    resultat_transaction(mnesia:transaction(fun() ->
 463       e(
 464          qlc:sort(
 465             q([E#reponse_minichat.cible || E <- mnesia:table(reponse_minichat), E#reponse_minichat.repondant =:= M]),
 466             [{order, ascending}]
 467          ),
 468          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 469       )
 470    end)).
 471
 472
 473 % Renvoie les id des enfants d'un message M (les messages qui répondent à M)
 474 % ordrés du plus petit au plus grand.
 475 % @spec enfants_id(integer()) -> [integer()]
 476 enfants_id(M) ->
 477    resultat_transaction(mnesia:transaction(fun() ->
 478       e(
 479          qlc:sort(
 480             q([E#reponse_minichat.repondant || E <- mnesia:table(reponse_minichat), E#reponse_minichat.cible =:= M]),
 481             [{order, ascending}]
 482          ),
 483          [{tmpdir, ?KEY_SORT_TEMP_DIR}]
 484       )
 485    end)).
 486
 487
 488 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
 489 % On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance.
 490 est_une_reponse_a_user(Id_user, Id_mess) ->
 491    resultat_transaction(mnesia:transaction(
 492       fun() ->
 493          case mnesia:read({reponse_minichat, Id_mess}) of
 494             [] -> false;
 495             Cibles ->
 496                lists:any(
 497                   fun(#reponse_minichat{cible = Cible}) ->
 498                      case mnesia:read({minichat, Cible}) of
 499                         [#minichat{auteur_id = Id_user}] -> true;
 500                         _ -> false
 501                      end
 502                   end,
 503                   Cibles
 504                )
 505          end
 506       end
 507    )).
 508
 509
 510 % Est-ce que Id_user à répondu au message Id_mess
 511 % On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance.
 512 a_repondu_a_message(Id_user, Id_mess) ->
 513    resultat_transaction(mnesia:transaction(
 514       fun() ->
 515          case mnesia:match_object({reponse_minichat, '_', Id_mess}) of
 516             [] -> false;
 517             Reponses ->
 518                lists:any(
 519                   fun(#reponse_minichat{repondant = Reponse}) ->
 520                      case mnesia:read({minichat, Reponse}) of
 521                         [#minichat{auteur_id = Id_user}] -> true;
 522                         _ -> false
 523                      end
 524                   end,
 525                   Reponses
 526                )
 527          end
 528       end
 529    )).
 530
 531
 532 % Est-ce que Id_user possède Id_mess ?
 533 possede_message(Id_user, Id_mess) ->
 534    case mnesia:transaction(
 535             fun() ->
 536                e(q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 537             end
 538          ) of
 539       {atomic, [Id_user | []]} -> true;
 540       _ -> false
 541    end.
 542
 543
 544 % renvoie la liste des ip bannies
 545 % liste de {ip, temps_restant(en minutes), Users} ou Users est une liste de {pseudo, login}
 546 % TODO : déterminer la complexité de cette fonction. (Il n'y a pas d'index sur #user.last_ip)
 547 list_ban() ->
 548    resultat_transaction(mnesia:transaction(
 549       fun() ->
 550          Now = now(),
 551          e(qlc:keysort(1, q([
 552             {
 553                IP#ip_table.ip,
 554                delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now),
 555                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}])
 556             } ||
 557             IP <- mnesia:table(ip_table),
 558             if IP#ip_table.ban =:= undefined -> false; true -> date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration) > Now end
 559          ])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 560       end
 561    )).
 562
 563
 564 % Bannie une ip pour un certain temps (en minute).
 565 ban(IP, Duration) ->
 566    mnesia:transaction(
 567       fun() ->
 568          case mnesia:wread({ip_table, IP}) of
 569             [IP_tuple] ->
 570                mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
 571             _ ->
 572                mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
 573           end
 574       end
 575    ).
 576
 577
 578 % Débanni une ip
 579 deban(IP) ->
 580    ban(IP, 0).
 581
 582
 583 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
 584 % ou false.
 585 est_banni(User_id) ->
 586    resultat_transaction(mnesia:transaction(
 587       fun() ->
 588          case e(q([
 589             {IP#ip_table.ban, IP#ip_table.ban_duration} ||
 590             U <- mnesia:table(user),
 591             U#user.id =:= User_id,
 592             IP <- mnesia:table(ip_table),
 593             IP#ip_table.ip =:= U#user.last_ip
 594          ]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 595             [{Ban, Ban_duration}] ->
 596                Echeance = date_plus_minutes(Ban, Ban_duration),
 597                Now = now(),
 598                if Echeance < Now -> % l'échéance est passée
 599                      false;
 600                   true ->
 601                      {true, delta_date_minute(Echeance, Now)}
 602                end;
 603             _ ->
 604                false
 605          end
 606       end
 607    )).
 608
 609
 610 % Ban est une date tel que retourner par now().
 611 % Ban_duration est un temps en minutes.
 612 % retourne une date.
 613 date_plus_minutes(Ban, Ban_duration) ->
 614    Duration_sec = Ban_duration * 60,
 615    {MegaSec, Sec, MicroSec} = Ban,
 616    {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
 617
 618
 619 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
 620 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
 621 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
 622 can_register(IP) ->
 623    resultat_transaction(mnesia:transaction(
 624       fun() ->
 625          case e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 626             [] ->
 627                mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
 628                true;
 629             [T] ->
 630                Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
 631                if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
 632                      false;
 633                   true ->
 634                      mnesia:write(#ip_table{
 635                         ip = IP,
 636                         date_last_try_register = now(),
 637                         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
 638                      }),
 639                      true
 640                end
 641          end
 642       end
 643    )).
 644
 645
 646 % Renvoie tous les trolls
 647 trolls() ->
 648    resultat_transaction(mnesia:transaction(
 649       fun() ->
 650          e(qlc:keysort(#troll.id, q([T || T <- mnesia:table(troll)])), [{tmpdir, ?KEY_SORT_TEMP_DIR}])
 651       end
 652    )).
 653
 654
 655 % Renvoie les trolls manquants posté après Last_id.
 656 trolls(Last_id) ->
 657    resultat_transaction(mnesia:transaction(
 658       fun() ->
 659          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}])
 660       end
 661    )).
 662
 663
 664  % Crée un nouveau troll.
 665  % Renvoie l'id du nouveau troll
 666  % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind
 667  % ou max_troll_reached si le nombre de troll posté max a été atteind
 668  % ou user_unknown
 669 put_troll(User_id, Content) ->
 670    resultat_transaction(mnesia:transaction(
 671       fun() ->
 672          % control le nombre de troll déjà posté
 673          Nb_troll_poste_par_user = length(e(q(
 674             [
 675                E#troll.id || E <- mnesia:table(troll),
 676                E#troll.id_user =:= User_id,
 677                E#troll.date_post =:= undefined
 678             ]
 679          ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])),
 680          Nb_troll_poste_total = length(e(q(
 681             [
 682                E#troll.id || E <- mnesia:table(troll),
 683                E#troll.date_post =:= undefined
 684             ]
 685          ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])),
 686          User = user_by_id(User_id),
 687          case User of
 688             {ok, _} ->
 689                if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER ->
 690                      max_troll_reached_per_user;
 691                   Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING ->
 692                      max_troll_reached;
 693                   true ->
 694                      Id = nouvel_id(minichat),
 695                      mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}),
 696                      Id
 697                end;
 698             _ ->
 699                user_unknown
 700          end
 701       end
 702    )).
 703
 704
 705 % renvoie ok | erreur
 706 mod_troll(Troll_id, Content) ->
 707    mnesia:transaction(
 708       fun() ->
 709          case mnesia:wread({troll, Troll_id}) of
 710             [Troll = #troll{date_post = undefined}] ->
 711                mnesia:write(Troll#troll{content = Content});
 712             _ ->
 713                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 714           end
 715       end
 716    ).
 717
 718
 719 del_troll(Troll_id) ->
 720    mnesia:transaction(
 721       fun() ->
 722          case mnesia:wread({troll, Troll_id}) of
 723             [#troll{date_post = undefined}] ->
 724                mnesia:delete({troll, Troll_id});
 725             _ ->
 726                mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
 727           end
 728       end
 729    ).
 730
 731
 732 troll_by_id(Troll_id) ->
 733    resultat_transaction(mnesia:transaction(
 734       fun() ->
 735          case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 736             [T] -> {ok, T};
 737             _ ->
 738                erreur
 739          end
 740       end
 741    )).
 742
 743
 744 % Renvoie le troll actuel qui se trouve sur la page principale.
 745 % Renvois aucun si pas de troll courant.
 746 current_troll() ->
 747    resultat_transaction(mnesia:transaction(
 748       fun() ->
 749          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}]),
 750          R = case qlc:next_answers(C, 1) of
 751             [T] -> T;
 752             _ -> aucun
 753          end,
 754          qlc:delete_cursor(C),
 755          R
 756       end
 757    )).
 758
 759
 760 % Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined)
 761 % Un message est posté par 'Sys' et le troll elu est lié à ce message
 762 % met à jour sa date de post.
 763 % renvoie plus_de_trolls si il n'y a aucun troll en attente.
 764 elire_troll() ->
 765    {A1,A2,A3} = now(),
 766    random:seed(A1, A2, A3),
 767    mnesia:transaction(
 768       fun() ->
 769          case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 770             [] ->
 771                plus_de_trolls;
 772             Trolls ->
 773                Troll = lists:nth(random:uniform(length(Trolls)), Trolls),
 774                Troll2 = Troll#troll{date_post = now()},
 775                mnesia:write(Troll2),
 776                nouveau_message_sys("Troll de la semaine : ", Troll2#troll.id)
 777          end
 778       end
 779    ).
 780
 781
 782 % Renvoie l'id du message associé au troll dont l'id est donnée.
 783 % Renvoie undefined si il n'y en a pas.
 784 message_id_associe(Troll_id) ->
 785    resultat_transaction(mnesia:transaction(
 786       fun() ->
 787          case e(q([M#minichat.id || M <- mnesia:table(minichat), M#minichat.troll_id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of
 788             [Id] -> Id;
 789             _ -> undefined
 790          end
 791       end
 792    )).
 793
 794
 795 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
 796 resultat_transaction({_, T}) ->
 797    T.
 798
 799
 800 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
 801 delta_date_ms(D1, D2) ->
 802    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).
 803
 804 % Retourne la différence entre deux timestamp (erlang:now) en minutes
 805 delta_date_minute(D1, D2) ->
 806    trunc(delta_date_ms(D1, D2) / 1000 / 60).
 807
 808
 809 % Renvoie un nouvel id pour une table donnée
 810 nouvel_id(Table) ->
 811    mnesia:dirty_update_counter(counter, Table, 1).
 812