X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_minichat.erl;fp=modules%2Ferl%2Feuphorik_minichat.erl;h=0000000000000000000000000000000000000000;hp=9ad6da2caf10c0736d404b2941458601455fc90e;hb=2233e8f8760b118c3cacf541ef32ea456a8e1527;hpb=218e748e517e9b88c6bcb2eb88ed28cd536b3d4e

diff --git a/modules/erl/euphorik_minichat.erl b/modules/erl/euphorik_minichat.erl
deleted file mode 100755
index 9ad6da2..0000000
--- a/modules/erl/euphorik_minichat.erl
+++ /dev/null
@@ -1,494 +0,0 @@
-% coding: utf-8
-% Ce module permet de gérer les données persistantes lié au site d'euphorik.ch.
-% Il permet d'ajouter des message, de demande les messages sur une page donnée, etc..
-% Ce module utilise une base mnesia.
-% @author G.Burri
-
--module(euphorik_minichat).
--export([
-   % gestion :
-   create/0,
-   connect/0,
-   connect/1,
-   reset/0,
-   
-   % users :
-   nouveau_user/2,
-   nouveau_user/3,
-   set_profile/9,
-   update_date_derniere_connexion/1,
-   update_pseudo_user/2,
-   users/0,
-   user_by_cookie/1,   
-   user_by_id/1,   
-   user_by_login/1,
-   user_by_login_password/2,
-   user_by_mess/1,
-   
-   % messages :
-   nouveau_message/3,
-   messages/1,
-   messages/2,
-   messages/3,
-   message_by_id/1,
-   messages_by_ids/1,
-   message_existe/1,
-   reponses/0,
-   repond_a/1,
-   est_une_reponse_a_user/2,
-   a_repondu_a_message/2,
-   possede_message/2,
-   
-   % utiles :
-   can_register/1,
-   resultat_transaction/1
-]).
-
--include("../include/euphorik_bd.hrl").
--include("../include/euphorik_defines.hrl").
--include_lib("stdlib/include/qlc.hrl").
-
-
-% Instructions pour créer une nouvelle base : 
-% $erl -sname yaws -mnesia dir '"/projets/euphorik/BD"'
-% voir doc/installation.txt
-% >l(euphorik_bd).
-% >euphorik_bd:create().
-create() ->
-   mnesia:stop(),
-   mnesia:delete_schema([node()]),
-   mnesia:create_schema([node()]), % nécessaire pour les tables sur disc
-   mnesia:start(),
-   create_tables(),
-   reset().
-create_tables() ->
-   mnesia:create_table(counter, [
-      {attributes, record_info(fields, counter)},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(minichat, [
-      {attributes, record_info(fields, minichat)},
-      {index, [auteur_id]},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(reponse_minichat, [
-      {type, bag},
-      {attributes, record_info(fields, reponse_minichat)},
-      {index, [cible]},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(user, [
-      {attributes, record_info(fields, user)},
-      {index, [cookie, login]},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(ip_table, [
-      {attributes, record_info(fields, ip_table)},
-      {disc_copies, [node()]}
-   ]),
-   mnesia:create_table(troll, [
-      {attributes, record_info(fields, troll)},
-      {disc_copies, [node()]}
-   ]).
-   
-   
-% Connexion à la base de données de yaws sur overnux
-connect() ->
-   connect(yaws@flynux).
-connect(Node) ->
-   mnesia:start(),
-   mnesia:change_config(extra_db_nodes, [Node]).
-
-
-% Efface tous les users, minichat_reponse et minichat.
-reset() ->
-   mnesia:clear_table(counter),
-   mnesia:clear_table(user),
-   mnesia:clear_table(reponse_minichat),
-   mnesia:clear_table(minichat),
-   % crée l'utilisateur root
-   mnesia:transaction(fun() ->
-      User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now()},
-      mnesia:write(User),
-      User
-   end).
-
-
-% Ajoute un nouveau user et le renvoie
-nouveau_user(Pseudo, Cookie) ->
-   F = fun() ->
-      Id = nouvel_id(user),
-      User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()},
-      mnesia:write(User),
-      User
-   end,
-  resultat_transaction(mnesia:transaction(F)).
-  
-  
-% Ajoute un nouveau user et le renvoie
-nouveau_user(Login, Password, Cookie) ->
-   F = fun() ->
-      Id = nouvel_id(user),
-      User = #user{id = Id, cookie = Cookie, pseudo = Login, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now()},
-      mnesia:write(User),
-      User
-   end,
-  resultat_transaction(mnesia:transaction(F)).
-
-
-% Mise à par Cookie les autres peuvent être undefined ce qui veut dire qu'ils ne seront pas modifié.
-set_profile(Cookie, Login, Password, Pseudo, Email, Css, Nick_format, Page_principale, Conversations) ->
-   if Nick_format =:= nick; Nick_format =:= login; Nick_format =:= nick_login ->
-         resultat_transaction(mnesia:transaction(
-            fun() ->
-               case user_by_cookie(Cookie) of
-                  {ok, User} ->               
-                     case user_by_login(Login) of
-                        {ok, U} when User#user.login =/= [], U#user.id =/= User#user.id ->
-                           login_deja_pris;
-                        _ ->               
-                           User_modifie = User#user{
-                              % TODO : pourquoi ne pas tester avec la valeur "undefined" plutôt qu'avec "is_list" ?
-                              % TODO : validation plus strict des données (pas de page négative dans les conv par exemple)
-                              login = if is_list(Login) -> Login; true -> User#user.login end,
-                              password = if is_list(Password) -> Password; true -> User#user.password end,
-                              pseudo = if is_list(Pseudo) -> Pseudo; true -> User#user.pseudo end,
-                              email = if is_list(Email) -> Email; true -> User#user.email end,
-                              css = if is_list(Css) -> Css; true -> User#user.css end,
-                              nick_format = Nick_format,
-                              page_principale = if is_integer(Page_principale), Page_principale > 0 -> Page_principale; true -> User#user.page_principale end,
-                              conversations = if is_list(Conversations) -> Conversations; true -> User#user.conversations end
-                           },
-                           mnesia:write(User_modifie),
-                           ok
-                     end;
-                  _ -> erreur
-               end
-            end
-         ));
-      true ->
-         erreur
-   end.
-
-
-% Met à jour la date de la dernière connexion d'un utilisateur à maintenant
-update_date_derniere_connexion(UserId) ->
-   mnesia:transaction(
-      fun() ->
-         case mnesia:wread({user, UserId}) of
-            [User] ->
-               mnesia:write(User#user{date_derniere_connexion = now()});
-            _ ->
-               mnesia:abort("update_date_derniere_connexion: User inconnu")
-          end
-      end
-   ).   
-  
-  
-% Met à jour le pseudo du user
-update_pseudo_user(UserId, Pseudo) ->
-   mnesia:transaction(
-      fun() ->      
-         case mnesia:wread({user, UserId}) of
-            [User] when User#user.pseudo =/= Pseudo ->
-               mnesia:write(User#user{pseudo = Pseudo});
-            _ ->
-               mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
-          end
-      end
-   ).
-   
-
-% Renvoie tous les users.
-users() ->
-   resultat_transaction(mnesia:transaction(fun() ->
-      qlc:e(qlc:q([E || E <- mnesia:table(user)]))
-   end)).   
-   
-
-% Est-ce qu'un utilisateur existe en fonction de son cookie ?
-% Renvoie {ok, User} ou erreur
-user_by_cookie(Cookie) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie])),
-         case Users of
-            [User] -> {ok, User};
-            _ -> erreur
-         end
-      end
-   )).
-   
-   
-user_by_id(ID) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= ID])),
-         case Users of
-            [User] -> {ok, User};
-            _ -> erreur
-         end
-      end
-   )).
-   
-   
-user_by_login(Login) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.login =:= Login])),
-         case Users of
-            [User] -> {ok, User};
-            _ -> erreur
-         end
-      end
-   )).
-   
-   
-user_by_login_password(Login, Password) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         Users = qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password])),
-         case Users of
-            [User] -> {ok, User};
-            _ -> erreur
-         end
-      end
-   )).
-   
-   
-% Renvoie {ok, User} où User est un #user possédant le message donné.
-user_by_mess(Id) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         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
-            [User] -> {ok, User};
-            _ -> erreur
-         end
-      end
-   )).
-   
-   
-% Renvoie l'utilisateur root
-root() ->
-   {ok, User} = user_by_id(0),
-   User.
-   
-   
-% Ajoute un message. Repond_A est une liste d'id auquel le message répond
-% retourne soit l'id du message soit erreur.
-nouveau_message(Mess, Auteur_id, Repond_A) ->
-   % regarde si les id 'Repond_A' existent
-   F = fun() ->   
-      Nb_id_trouve = length(qlc:e(qlc:q([E#minichat.id || E <- mnesia:table(minichat), lists:member(E#minichat.id, Repond_A)]))),
-      % est-ce que l'auteur existe ?
-      Auteur = case qlc:e(qlc:q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id])) of
-         [A] -> A;
-         _ -> throw("L'auteur du message est introuvable")
-      end,
-      if Nb_id_trouve =/= length(Repond_A) -> throw("Un ou plusieurs messages introuvable");
-         true -> ok
-      end,
-      Id = nouvel_id(minichat),
-      % compare les dernière
-      Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
-      Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
-      Auteur_maj = Auteur#user{
-         indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
-         date_derniere_connexion = now()
-      },
-      % est-ce que l'auteur à trop floodé ?
-      if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
-         Root = root(),
-         mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
-         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.."}),
-         Id;
-      Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
-         erreur;
-      true ->     
-         mnesia:write(Auteur_maj),
-         inserer_reponses(Id, Repond_A),
-         mnesia:write(#minichat{id=Id, auteur_id=Auteur#user.id, date=now(), pseudo=Auteur#user.pseudo, contenu=Mess}),
-         Id
-      end
-   end,
-   resultat_transaction(mnesia:transaction(F)).
-   
-% Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
-inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
-   mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
-   inserer_reponses(Id_repondant, Reste);
-inserer_reponses(_, []) ->
-   ok.
-   
-   
-% Renvoie N messages se trouvant sur la première page
-messages(N) ->  
-   messages(N, 1).
-
-
-% Renvoie N messages se trouvant sur la page P
-messages(N, P) ->  
-   F = fun() ->
-      C = qlc:cursor(qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, descending}])])),
-      if P > 1 -> qlc:next_answers(C, N * (P - 1));
-         true -> ok
-      end,
-      R = qlc:next_answers(C, N),
-      qlc:delete_cursor(C),
-      lists:reverse(R)
-   end,
-   resultat_transaction(mnesia:transaction(F)).   
-
-
-% Renvoie les messages manquants pour la page P en sachant qu'il y a N message
-% par page et que le dernier message que l'on possède est Id
-messages(Id, N, P) ->
-   lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
-   
-   
-% Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
-message_by_id(Id) ->
-   case resultat_transaction(mnesia:transaction(
-      fun() ->
-         qlc:e(qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), Id =:= E#minichat.id]))
-      end
-   )) of
-      [M] -> {ok, M};
-      _ -> erreur
-   end.
-  
-
-% Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
-messages_by_ids(Ids) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         % TODO : optimisations ? serait-ce du O(n) ?
-         Query = qlc:q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
-         %io:format("~s~n", [qlc:info(Query)]),
-         qlc:e(Query)
-      end
-   )).
-   
-
-% Est-ce qu'un message existe ? Renvoie un boolean.
-% TODO : ya pas plus simple ?
-message_existe(Id) ->
-   resultat_transaction(mnesia:transaction(fun() ->
-      length(qlc:e(qlc:q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]))) =:= 1
-   end)).
-   
-   
-% Renvoie les reponses (utilisé normalement uniquement pendant le debug).
-reponses() ->
-   F = fun() ->
-      qlc:e(qlc:q([E || E <- mnesia:table(reponse_minichat)]))
-   end,
-   resultat_transaction(mnesia:transaction(F)).
-   
-   
-% Renvoie les messages auquel M_id répond.
-repond_a(M_id) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         qlc:e(qlc:q(
-            [M || E <- mnesia:table(reponse_minichat),
-            M <- mnesia:table(minichat),
-            E#reponse_minichat.repondant =:= M_id,
-            M#minichat.id =:= E#reponse_minichat.cible]))
-      end
-   )).
-   
-
-% Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
-est_une_reponse_a_user(Id_user, Id_mess) ->
-   case mnesia:transaction(
-            fun() ->
-               qlc:e(qlc:q([
-                  M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
-                  M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
-               ]), [{unique_all, true}])
-            end
-         ) of
-      {atomic, [_]} -> true;
-      _ -> false
-   end.
-
-   
-% Est-ce que Id_user à répondu au message Id_mess
-a_repondu_a_message(Id_user, Id_mess) ->
-   case mnesia:transaction(
-            fun() ->
-               qlc:e(qlc:q([
-                  M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
-                  R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
-               ]), [{unique_all, true}])
-            end
-         ) of
-      {atomic, [_]} -> true;
-      _ -> false
-   end.
-   
-   
-% Est-ce que Id_user possède Id_mess ?
-possede_message(Id_user, Id_mess) ->
-   case mnesia:transaction(
-            fun() ->
-               qlc:e(qlc:q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]))
-            end
-         ) of
-      {atomic, [Id_user | []]} -> true;
-      _ -> false
-   end.
-   
-   
-% Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors 
-% ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
-% Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
-can_register(IP) ->
-   resultat_transaction(mnesia:transaction(
-      fun() ->
-         case qlc:e(qlc:q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP])) of
-            [] -> 
-               mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
-               true;
-            [T] ->
-               Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
-               if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
-                     false;
-                  true ->
-                     mnesia:write(#ip_table{
-                        ip = IP,
-                        date_last_try_register = now(),
-                        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
-                     }),
-                     true
-               end
-         end
-      end
-   )).
-   
-   
-% Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
-resultat_transaction({_, T}) ->
-   T.
-   
-
-% Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
-delta_date_ms(D1, D2) ->
-   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).
-
-
-% Bizarre, cette fonction n'existe pas dans la stdlib.
-ceiling(X) ->
-   T = trunc(X),
-   case (X - T) of
-      Neg when Neg < 0 -> T;
-      Pos when Pos > 0 -> T + 1;
-      _ -> T
-   end.
-
-
-% Renvoie un nouvel id pour une table donnée
-nouvel_id(Table) ->
-   mnesia:dirty_update_counter(counter, Table, 1).
-   
\ No newline at end of file