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