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