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