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    users/0,
  23    user_by_cookie/1,
  24    user_by_id/1,
  25    user_by_login/1,
  26    user_by_login_password/2,
  27    user_by_mess/1,
  28    toggle_ek_master/1,
  29
  30    % messages :
  31    nouveau_message/3,
  32    nouveau_message_sys/1,
  33    messages/1,
  34    messages/2,
  35    messages/3,
  36    message_by_id/1,
  37    messages_by_ids/1,
  38    message_existe/1,
  39    reponses/0,
  40    repond_a/1,
  41    est_une_reponse_a_user/2,
  42    a_repondu_a_message/2,
  43    possede_message/2,
  44
  45    % ip :
  46    ip_table/0,
  47    ban/2,
  48    deban/1,
  49    est_banni/1,
  50    can_register/1,
  51
  52    % versions :
  53    update_version/1,
  54
  55    % utiles :
  56    resultat_transaction/1
  57 ]).
  58
  59 -include("../include/euphorik_bd.hrl").
  60 -include("../include/euphorik_defines.hrl").
  61 -include_lib("stdlib/include/qlc.hrl").
  62
  63
  64 % Instructions pour créer une nouvelle base :
  65 % $erl -sname yaws -mnesia dir '"/projets/euphorik/BD"'
  66 % voir doc/installation.txt
  67 % >l(euphorik_bd).
  68 % >euphorik_bd:create().
  69 create() ->
  70    mnesia:stop(),
  71    mnesia:delete_schema([node()]),
  72    mnesia:create_schema([node()]), % nécessaire pour les tables sur disc
  73    mnesia:start(),
  74    create_tables(),
  75    reset().
  76 create_tables() ->
  77    mnesia:create_table(counter, [
  78       {attributes, record_info(fields, counter)},
  79       {disc_copies, [node()]}
  80    ]),
  81    mnesia:create_table(minichat, [
  82       {attributes, record_info(fields, minichat)},
  83       {index, [auteur_id]},
  84       {disc_copies, [node()]}
  85    ]),
  86    mnesia:create_table(reponse_minichat, [
  87       {type, bag},
  88       {attributes, record_info(fields, reponse_minichat)},
  89       {index, [cible]},
  90       {disc_copies, [node()]}
  91    ]),
  92    mnesia:create_table(user, [
  93       {attributes, record_info(fields, user)},
  94       {index, [cookie, login]},
  95       {disc_copies, [node()]}
  96    ]),
  97    mnesia:create_table(ip_table, [
  98       {attributes, record_info(fields, ip_table)},
  99       {disc_copies, [node()]}
 100    ]),
 101    mnesia:create_table(troll, [
 102       {attributes, record_info(fields, troll)},
 103       {index, [date_post]},
 104       {disc_copies, [node()]}
 105    ]).
 106
 107
 108 % Connexion à la base de données de yaws sur overnux
 109 connect() ->
 110    connect(yaws@flynux).
 111 connect(Node) ->
 112    mnesia:start(),
 113    mnesia:change_config(extra_db_nodes, [Node]).
 114
 115
 116 % Efface tous les users, minichat_reponse et minichat.
 117 reset() ->
 118    mnesia:clear_table(counter),
 119    mnesia:clear_table(user),
 120    mnesia:clear_table(reponse_minichat),
 121    mnesia:clear_table(minichat),
 122    mnesia:clear_table(ip_table),
 123    % crée l'utilisateur root
 124    mnesia:transaction(fun() ->
 125       User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now(), ek_master = true},
 126       mnesia:write(User),
 127       User
 128    end).
 129
 130
 131 % Ajoute un nouveau user et le renvoie
 132 nouveau_user(Pseudo, Cookie) ->
 133    F = fun() ->
 134       Id = nouvel_id(user),
 135       User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()},
 136       mnesia:write(User),
 137       User
 138    end,
 139   resultat_transaction(mnesia:transaction(F)).
 140
 141
 142 % Ajoute un nouveau user et le renvoie
 143 nouveau_user(Login, Password, Cookie) ->
 144    F = fun() ->
 145       Id = nouvel_id(user),
 146       User = #user{id = Id, cookie = Cookie, pseudo = Login, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now()},
 147       mnesia:write(User),
 148       User
 149    end,
 150   resultat_transaction(mnesia:transaction(F)).
 151
 152
 153 % Mise à par Cookie les autres peuvent être undefined ce qui veut dire qu'ils ne seront pas modifié.
 154 set_profile(Cookie, Login, Password, Pseudo, Email, Css, Nick_format, Page_principale, Conversations) ->
 155    if Nick_format =:= nick; Nick_format =:= login; Nick_format =:= nick_login ->
 156          resultat_transaction(mnesia:transaction(
 157             fun() ->
 158                case user_by_cookie(Cookie) of
 159                   {ok, User} ->
 160                      case user_by_login(Login) of
 161                         {ok, U} when User#user.login =/= [], U#user.id =/= User#user.id ->
 162                            login_deja_pris;
 163                         _ ->
 164                            User_modifie = User#user{
 165                               % TODO : pourquoi ne pas tester avec la valeur "undefined" plutôt qu'avec "is_list" ?
 166                               % TODO : validation plus strict des données (pas de page négative dans les conv par exemple)
 167                               login = if is_list(Login) -> Login; true -> User#user.login end,
 168                               password = if is_list(Password) andalso Password =/= [] -> Password; true -> User#user.password end,
 169                               pseudo = if is_list(Pseudo) -> Pseudo; true -> User#user.pseudo end,
 170                               email = if is_list(Email) -> Email; true -> User#user.email end,
 171                               css = if is_list(Css) -> Css; true -> User#user.css end,
 172                               nick_format = Nick_format,
 173                               page_principale = if is_integer(Page_principale), Page_principale > 0 -> Page_principale; true -> User#user.page_principale end,
 174                               conversations = if is_list(Conversations) -> Conversations; true -> User#user.conversations end
 175                            },
 176                            mnesia:write(User_modifie),
 177                            ok
 178                      end;
 179                   _ -> erreur
 180                end
 181             end
 182          ));
 183       true ->
 184          erreur
 185    end.
 186
 187
 188 % Met à jour la date de la dernière connexion d'un utilisateur à maintenant
 189 update_date_derniere_connexion(User_id) ->
 190    mnesia:transaction(
 191       fun() ->
 192          case mnesia:wread({user, User_id}) of
 193             [User] ->
 194                mnesia:write(User#user{date_derniere_connexion = now()});
 195             _ ->
 196                mnesia:abort("update_date_derniere_connexion: User inconnu")
 197           end
 198       end
 199    ).
 200
 201
 202 % Met à jour l'ip d'un user
 203 update_ip(User_id, IP) ->
 204    mnesia:transaction(
 205       fun() ->
 206          case mnesia:wread({user, User_id}) of
 207             [User] ->
 208                mnesia:write(User#user{last_ip = IP});
 209             _ ->
 210                mnesia:abort("update_ip: User inconnu")
 211           end
 212       end
 213    ).
 214
 215
 216 % Met à jour le pseudo du user
 217 update_pseudo_user(UserId, Pseudo) ->
 218    mnesia:transaction(
 219       fun() ->
 220          case mnesia:wread({user, UserId}) of
 221             [User] when User#user.pseudo =/= Pseudo ->
 222                mnesia:write(User#user{pseudo = Pseudo});
 223             _ ->
 224                mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
 225           end
 226       end
 227    ).
 228
 229
 230 % Renvoie tous les users.
 231 users() ->
 232    resultat_transaction(mnesia:transaction(fun() ->
 233       qlc:e(qlc:q([E || E <- mnesia:table(user)]))
 234    end)).
 235
 236
 237 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
 238 % Renvoie {ok, User} ou erreur
 239 user_by_cookie(Cookie) ->
 240    resultat_transaction(mnesia:transaction(
 241       fun() ->
 242          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie])),
 243          case Users of
 244             [User] -> {ok, User};
 245             _ -> erreur
 246          end
 247       end
 248    )).
 249
 250
 251 user_by_id(ID) ->
 252    resultat_transaction(mnesia:transaction(
 253       fun() ->
 254          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= ID])),
 255          case Users of
 256             [User] -> {ok, User};
 257             _ -> erreur
 258          end
 259       end
 260    )).
 261
 262
 263 user_by_login(Login) ->
 264    resultat_transaction(mnesia:transaction(
 265       fun() ->
 266          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.login =:= Login])),
 267          case Users of
 268             [User] -> {ok, User};
 269             _ -> erreur
 270          end
 271       end
 272    )).
 273
 274
 275 toggle_ek_master(User_id) ->
 276    resultat_transaction(mnesia:transaction(
 277       fun() ->
 278          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= User_id])),
 279          case Users of
 280             [User] ->
 281                mnesia:write(User#user{ek_master = not User#user.ek_master});
 282             _ -> erreur
 283          end
 284       end
 285    )).
 286
 287
 288 user_by_login_password(Login, Password) ->
 289    resultat_transaction(mnesia:transaction(
 290       fun() ->
 291          Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password])),
 292          case Users of
 293             [User] -> {ok, User};
 294             _ -> erreur
 295          end
 296       end
 297    )).
 298
 299
 300 % Renvoie {ok, User} où User est un #user possédant le message donné.
 301 user_by_mess(Id) ->
 302    resultat_transaction(mnesia:transaction(
 303       fun() ->
 304          case qlc:e(qlc:q([U || U <- mnesia:table(user), M <- mnesia:table(minichat), M#minichat.id =:= Id, M#minichat.auteur_id =:= U#user.id])) of
 305             [User] -> {ok, User};
 306             _ -> erreur
 307          end
 308       end
 309    )).
 310
 311
 312 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
 313 % retourne soit l'id du message soit erreur.
 314 nouveau_message(Mess, Auteur_id, Repond_A) ->
 315    % regarde si les id 'Repond_A' existent
 316    F = fun() ->
 317       Nb_id_trouve = length(qlc:e(qlc:q([E#minichat.id || E <- mnesia:table(minichat), lists:member(E#minichat.id, Repond_A)]))),
 318       % est-ce que l'auteur existe ?
 319       Auteur = case qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id])) of
 320          [A] -> A;
 321          _ -> throw("L'auteur du message est introuvable")
 322       end,
 323       if Nb_id_trouve =/= length(Repond_A) -> throw("Un ou plusieurs messages introuvable");
 324          true -> ok
 325       end,
 326       % compare les dernière
 327       Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
 328       Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
 329       Auteur_maj = Auteur#user{
 330          indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
 331          date_derniere_connexion = now()
 332       },
 333       % est-ce que l'auteur à trop floodé ?
 334       if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 335          mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
 336          nouveau_message_sys(Auteur#user.pseudo ++ "(" ++ Auteur#user.login ++ ") est bloqué pour " ++ integer_to_list(trunc(?DUREE_BLOCAGE_SPAM / 1000)) ++ " secondes pour cause de flood..");
 337       Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
 338          erreur;
 339       true ->
 340          mnesia:write(Auteur_maj),
 341          Id = nouvel_id(minichat),
 342          inserer_reponses(Id, Repond_A),
 343          mnesia:write(#minichat{id=Id, auteur_id=Auteur#user.id, date=now(), pseudo=Auteur#user.pseudo, contenu=Mess}),
 344          Id
 345       end
 346    end,
 347    resultat_transaction(mnesia:transaction(F)).
 348
 349 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
 350 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
 351    mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
 352    inserer_reponses(Id_repondant, Reste);
 353 inserer_reponses(_, []) ->
 354    ok.
 355
 356
 357 % Permet de créer un message système.
 358 % Renvoie l'id du message système
 359 nouveau_message_sys(Mess) ->
 360    {ok, Root} = user_by_id(0),
 361    mnesia:transaction(
 362       fun() ->
 363          Id = nouvel_id(minichat),
 364          mnesia:write(#minichat{id=Id, auteur_id=0, date=now(), pseudo=Root#user.pseudo, contenu=Mess})
 365       end
 366    ).
 367
 368
 369 % Renvoie N messages se trouvant sur la première page
 370 messages(N) ->
 371    messages(N, 1).
 372
 373
 374 % Renvoie N messages se trouvant sur la page P
 375 messages(N, P) ->
 376    F = fun() ->
 377       C = qlc:cursor(qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, descending}])])),
 378       if P > 1 -> qlc:next_answers(C, N * (P - 1));
 379          true -> ok
 380       end,
 381       R = qlc:next_answers(C, N),
 382       qlc:delete_cursor(C),
 383       lists:reverse(R)
 384    end,
 385    resultat_transaction(mnesia:transaction(F)).
 386
 387
 388 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
 389 % par page et que le dernier message que l'on possède est Id
 390 messages(Id, N, P) ->
 391    lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
 392
 393
 394 % Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
 395 message_by_id(Id) ->
 396    case resultat_transaction(mnesia:transaction(
 397       fun() ->
 398          qlc:e(qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), Id =:= E#minichat.id]))
 399       end
 400    )) of
 401       [M] -> {ok, M};
 402       _ -> erreur
 403    end.
 404
 405
 406 % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
 407 messages_by_ids(Ids) ->
 408    resultat_transaction(mnesia:transaction(
 409       fun() ->
 410          % TODO : optimisations ? serait-ce du O(n) ?
 411          Query = qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
 412          qlc:e(Query)
 413       end
 414    )).
 415
 416
 417 % Est-ce qu'un message existe ? Renvoie un boolean.
 418 % TODO : ya pas plus simple ?
 419 message_existe(Id) ->
 420    resultat_transaction(mnesia:transaction(fun() ->
 421       length(qlc:e(qlc:q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]))) =:= 1
 422    end)).
 423
 424
 425 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
 426 reponses() ->
 427    F = fun() ->
 428       qlc:e(qlc:q([E || E <- mnesia:table(reponse_minichat)]))
 429    end,
 430    resultat_transaction(mnesia:transaction(F)).
 431
 432
 433 % Renvoie les messages auquel M_id répond.
 434 repond_a(M_id) ->
 435    resultat_transaction(mnesia:transaction(
 436       fun() ->
 437          qlc:e(qlc:q(
 438             [M || E <- mnesia:table(reponse_minichat),
 439             M <- mnesia:table(minichat),
 440             E#reponse_minichat.repondant =:= M_id,
 441             M#minichat.id =:= E#reponse_minichat.cible]))
 442       end
 443    )).
 444
 445
 446 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
 447 est_une_reponse_a_user(Id_user, Id_mess) ->
 448    case mnesia:transaction(
 449             fun() ->
 450                qlc:e(qlc:q([
 451                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 452                   M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
 453                ]), [{unique_all, true}])
 454             end
 455          ) of
 456       {atomic, [_]} -> true;
 457       _ -> false
 458    end.
 459
 460
 461 % Est-ce que Id_user à répondu au message Id_mess
 462 a_repondu_a_message(Id_user, Id_mess) ->
 463    case mnesia:transaction(
 464             fun() ->
 465                qlc:e(qlc:q([
 466                   M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
 467                   R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
 468                ]), [{unique_all, true}])
 469             end
 470          ) of
 471       {atomic, [_]} -> true;
 472       _ -> false
 473    end.
 474
 475
 476 % Est-ce que Id_user possède Id_mess ?
 477 possede_message(Id_user, Id_mess) ->
 478    case mnesia:transaction(
 479             fun() ->
 480                qlc:e(qlc:q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]))
 481             end
 482          ) of
 483       {atomic, [Id_user | []]} -> true;
 484       _ -> false
 485    end.
 486
 487
 488 ip_table() ->
 489    resultat_transaction(mnesia:transaction(
 490       fun() ->
 491          qlc:e(qlc:q([IP || IP <- mnesia:table(ip_table)]))
 492       end
 493    )).
 494
 495
 496 % Bannie une ip pour un certain temps (en minute).
 497 ban(IP, Duration) ->
 498    mnesia:transaction(
 499       fun() ->
 500          case mnesia:wread({ip_table, IP}) of
 501             [IP_tuple] ->
 502                mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
 503             _ ->
 504                mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
 505           end
 506       end
 507    ).
 508
 509
 510 % Débanni une ip
 511 deban(IP) ->
 512    ban(IP, 0).
 513
 514
 515 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
 516 % ou false.
 517 est_banni(User_id) ->
 518    resultat_transaction(mnesia:transaction(
 519       fun() ->
 520          case qlc:e(qlc:q([
 521             {IP#ip_table.ban, IP#ip_table.ban_duration} ||
 522             U <- mnesia:table(user),
 523             U#user.id =:= User_id,
 524             IP <- mnesia:table(ip_table),
 525             IP#ip_table.ip =:= U#user.last_ip
 526          ])) of
 527             [{Ban, Ban_duration}] ->
 528                Echeance = date_plus_minutes(Ban, Ban_duration),
 529                Now = now(),
 530                if Echeance < Now -> % l'échéance est passée
 531                      false;
 532                   true ->
 533                      {true, trunc(delta_date_ms(Echeance, Now) / 1000 / 60)}
 534                end;
 535             _ ->
 536                false
 537          end
 538       end
 539    )).
 540
 541
 542 % Ban est une date tel que retourner par now().
 543 % Ban_duration est un temps en minutes.
 544 % retourne une date.
 545 date_plus_minutes(Ban, Ban_duration) ->
 546    Duration_sec = Ban_duration * 60,
 547    {MegaSec, Sec, MicroSec} = Ban,
 548    {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
 549
 550
 551 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
 552 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
 553 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
 554 can_register(IP) ->
 555    resultat_transaction(mnesia:transaction(
 556       fun() ->
 557          case qlc:e(qlc:q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP])) of
 558             [] ->
 559                mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
 560                true;
 561             [T] ->
 562                Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
 563                if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
 564                      false;
 565                   true ->
 566                      mnesia:write(#ip_table{
 567                         ip = IP,
 568                         date_last_try_register = now(),
 569                         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
 570                      }),
 571                      true
 572                end
 573          end
 574       end
 575    )).
 576
 577
 578 update_version(1) ->
 579    mnesia:transform_table(
 580       ip_table,
 581       fun() -> null end,
 582       record_info(fields, ip_table),
 583       ip_table
 584    ).
 585
 586
 587 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
 588 resultat_transaction({_, T}) ->
 589    T.
 590
 591
 592 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
 593 delta_date_ms(D1, D2) ->
 594    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).
 595
 596
 597 % Bizarre, cette fonction n'existe pas dans la stdlib.
 598 % Pas utilisé mais bon ca me fait de la peine de l'enlever.
 599 ceiling(X) ->
 600    T = trunc(X),
 601    case (X - T) of
 602       Neg when Neg < 0 -> T;
 603       Pos when Pos > 0 -> T + 1;
 604       _ -> T
 605    end.
 606
 607
 608 % Renvoie un nouvel id pour une table donnée
 609 nouvel_id(Table) ->
 610    mnesia:dirty_update_counter(counter, Table, 1).
 611