modules/erl/euphorik_minichat.erl

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