modules/erl/euphorik_bd.erl

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