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