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