X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_bd.erl;h=6b10f4b69968ee7455911594178665d7062793e1;hp=25398ad7d27b62fac677a974e782943ad0078242;hb=5d9992368bb386d2e606ae037c5478fe10ac70e8;hpb=bb692b6ec033e2c6ce4dd12d95831af96033ec6f diff --git a/modules/erl/euphorik_bd.erl b/modules/erl/euphorik_bd.erl index 25398ad..6b10f4b 100755 --- a/modules/erl/euphorik_bd.erl +++ b/modules/erl/euphorik_bd.erl @@ -15,44 +15,37 @@ % % You should have received a copy of the GNU General Public License % along with Euphorik. If not, see . -% +% % 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_bd). +-author("Greg Burri "). -export([ - % gestion : - create/0, - connect/0, - connect/1, - reset/0, - + % texte : + get_texte/1, + get_texte/2, + % users : nouveau_user/2, - nouveau_user/3, - set_profile/12, + nouveau_user/4, + set_profile/4, update_date_derniere_connexion/1, update_ip/2, update_pseudo_user/2, - print_users/0, - print_users/1, - print_user/1, - user_by_cookie/1, - user_by_id/1, + user_by_cookie/1, + user_by_id/1, user_by_login/1, user_by_login_password/2, user_by_mess/1, - toggle_ek_master/1, css_from_user_cookie/1, is_ek_master_from_cookie/1, - - % messages :e + + % messages : nouveau_message/3, nouveau_message_sys/1, - nouveau_message_sys/2, messages/1, messages/2, messages/3, @@ -67,27 +60,17 @@ est_une_reponse_a_user/2, a_repondu_a_message/2, possede_message/2, - + % ip : list_ban/0, ban/2, deban/1, est_banni/1, can_register/1, - - % trolls : - trolls/0, - trolls/1, - put_troll/2, - mod_troll/2, - del_troll/1, - troll_by_id/1, - current_troll/0, - elire_troll/0, - message_id_associe/1, - + % utiles : - resultat_transaction/1 + resultat_transaction/1, + get_tuples/3 % must be in a transaction ]). -import(qlc, [e/2, q/1, cursor/2]). -include("../include/euphorik_bd.hrl"). @@ -95,142 +78,65 @@ -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(proprietes, [ - {attributes, record_info(fields, proprietes)}, - {disc_copies, [node()]} - ]), - mnesia:create_table(minichat, [ - {attributes, record_info(fields, minichat)}, - {index, [auteur_id, troll_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)}, - {index, [date_post]}, - {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(proprietes), - mnesia:clear_table(user), - mnesia:clear_table(reponse_minichat), - mnesia:clear_table(minichat), - mnesia:clear_table(troll), - mnesia:clear_table(ip_table), - % crée l'utilisateur root - mnesia:transaction(fun() -> - mnesia:write(#proprietes{nom = version, valeur = ?VERSION_BD}), - User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now(), ek_master = true}, - mnesia:write(User), - User - end). +get_texte(Id) -> + get_texte(Id, fr). + + +% TODO : généraliser la langue +get_texte(Id, _Lang = fr) -> + resultat_transaction(mnesia:transaction(fun() -> + case mnesia:read({texte, Id}) of + [#texte{fr = Texte}] -> Texte; + _ -> "Message " ++ integer_to_list(Id) ++ " unknown" + end + end)). % Ajoute un nouveau user et le renvoie -nouveau_user(Pseudo, Cookie) -> +nouveau_user(Cookie, Profile) -> F = fun() -> Id = nouvel_id(user), - User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()}, + User = #user{id = Id, cookie = Cookie, date_creation = erlang:timestamp(), date_derniere_connexion = erlang:timestamp(), profile = Profile}, mnesia:write(User), User end, resultat_transaction(mnesia:transaction(F)). - - + + % Ajoute un nouveau user et le renvoie -nouveau_user(Login, Password, Cookie) -> +nouveau_user(Login, Password, Cookie, Profile) -> 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()}, + User = #user{id = Id, cookie = Cookie, login = Login, password = Password, date_creation = erlang:timestamp(), date_derniere_connexion = erlang:timestamp(), profile = Profile#profile{pseudo = Login}}, 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é. -% Conversation est de type [{int(), bool()}] où l'entier est la racine, le booléen indique si la conversation est réduite ou non -% Ostentatious_master peut valoir invisible, light ou heavy -set_profile(Cookie, Login, Password, Pseudo, Email, Css, Chat_order, Nick_format, View_times, View_tooltips, Conversations, Ostentatious_master) -> - if Nick_format =:= nick; Nick_format =:= login; Nick_format =:= nick_login, - Ostentatious_master =:= invisible; Ostentatious_master =:= light; Ostentatious_master =:= heavy -> - resultat_transaction(mnesia:transaction( - fun() -> - case user_by_cookie(Cookie) of - {ok, User} -> - case user_by_login(Login) of - {ok, U} when 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) andalso 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, - chat_order = Chat_order, - nick_format = Nick_format, - view_times = View_times, - view_tooltips = View_tooltips, - conversations = if is_list(Conversations) -> Conversations; true -> User#user.conversations end, - ostentatious_master = Ostentatious_master - }, - mnesia:write(User_modifie), - ok - end; - _ -> erreur - end - end - )); - true -> - erreur - end. +% Définit les données du profile d'une utilisateur. +set_profile(Cookie, Login, Password, Profile) -> + resultat_transaction(mnesia:transaction( + fun() -> + case user_by_cookie(Cookie) of + {ok, User_existant} -> + case user_by_login(Login) of + {ok, U} when Login =/= [], U#user.id =/= User_existant#user.id -> + login_deja_pris; + _ -> + mnesia:write( + User_existant#user{ + login = if User_existant#user.login =:= [] -> Login; true -> User_existant#user.login end, % on ne peut pas changer de login sauf si on en a pas ! + password = if Password =:= [] -> User_existant#user.password; true -> Password end, + profile = Profile + } + ), + ok + end; + _ -> erreur + end + end + )). % Met à jour la date de la dernière connexion d'un utilisateur à maintenant @@ -239,12 +145,12 @@ update_date_derniere_connexion(User_id) -> fun() -> case mnesia:wread({user, User_id}) of [User] -> - mnesia:write(User#user{date_derniere_connexion = now()}); + mnesia:write(User#user{date_derniere_connexion = erlang:timestamp()}); _ -> mnesia:abort("update_date_derniere_connexion: User inconnu") end end - ). + ). % Met à jour l'ip d'un user @@ -258,116 +164,51 @@ update_ip(User_id, IP) -> mnesia:abort("update_ip: User inconnu") end end - ). - - + ). + + % Met à jour le pseudo du user update_pseudo_user(UserId, Pseudo) -> mnesia:transaction( - fun() -> + fun() -> case mnesia:wread({user, UserId}) of - [User] when User#user.pseudo =/= Pseudo -> - mnesia:write(User#user{pseudo = Pseudo}); + [#user{profile = Profile} = User] when Profile#profile.pseudo =/= Pseudo -> + mnesia:write(User#user{profile = Profile#profile { pseudo = Pseudo } }); _ -> mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour") end end ). - - -% Affiche N user trié par leur date de dernière connexion. -% Opt est une liste d'option d'affichage : -% * ekmaster : n'affiche que les admins -print_users(N, Opt) -> - AfficheQueLesEkMaster = lists:any(fun(O) -> O =:= ekmaster end, Opt), - resultat_transaction(mnesia:transaction(fun() -> - C = cursor( - qlc:keysort( - #user.date_derniere_connexion, - if AfficheQueLesEkMaster -> - q([E || E <- mnesia:table(user), E#user.ek_master =:= true]); - true -> - q([E || E <- mnesia:table(user)]) - end, - [{order, descending}] - ), - [{tmpdir, ?KEY_SORT_TEMP_DIR}] - ), - Users = qlc:next_answers(C, N), - lists:foreach( - fun(U) -> - print_user(U) - end, - Users - ), - qlc:delete_cursor(C) - end)). - - -% Affiche tous les users. -print_users(Opt) -> - print_users(all_remaining, Opt). - -% Affiche tous les users. -print_users() -> - print_users(all_remaining, []). - -print_user(User) when is_record(User, user) -> - #user{id = Id, pseudo = Pseudo, login = Login, ek_master = Ek_master, date_derniere_connexion = Date, last_ip = IP} = User, - {{Annee, Mois, Jour}, {Heure, Min, _}} = calendar:now_to_local_time(Date), - io:format( - % id pseudo (login) IP Jour Mois Année Heure Minute - "~4w : ~10.10..s(~10.10..s) ~s ~2w.~2.2.0w.~w - ~2wh~2.2.0w~n", - [ - Id, - if Ek_master -> "*"; true -> "" end ++ Pseudo, - Login, - euphorik_common:serialize_ip(IP), - Jour, Mois, Annee, Heure, Min - ] - ); -% Affichage d'un user en fonction de son login -print_user(Login) when is_list(Login) -> - case user_by_login(Login) of - {ok, User} -> - print_user(User); - _ -> - {erreur, "Login pas trouvé : " ++ Login} - end; -% Affichage d'un user en fonction de son id -print_user(Id) when is_integer(Id) -> - case user_by_id(Id) of - {ok, User} -> - print_user(User); - _ -> - {erreur, "Id pas trouvé : " ++ integer_to_list(Id)} - 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() -> - case e(q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of + case mnesia:index_read(user, Cookie, #user.cookie) of [User] -> {ok, User}; _ -> erreur end end )). - - + + user_by_id(ID) -> resultat_transaction(mnesia:transaction( fun() -> - case e(q([E || E <- mnesia:table(user), E#user.id =:= ID]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of +% case e(q([E || E <- mnesia:table(user), E#user.id =:= ID]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of +% [User] -> {ok, User}; +% _ -> erreur +% end + case mnesia:read({user, ID}) of [User] -> {ok, User}; _ -> erreur end end )). - - + + user_by_login(Login) -> resultat_transaction(mnesia:transaction( fun() -> @@ -378,37 +219,24 @@ user_by_login(Login) -> end end )). - - -toggle_ek_master(User_id) -> - resultat_transaction(mnesia:transaction( - fun() -> - Users = e(q([E || E <- mnesia:table(user), E#user.id =:= User_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]), - case Users of - [User] -> - mnesia:write(User#user{ek_master = not User#user.ek_master}); - _ -> erreur - end - end - )). - + % Renvoie une chaine représentant le cookie ou undefined si pas trouvé. css_from_user_cookie(Cookie) -> - case user_by_cookie(Cookie) of - {ok, User} -> - User#user.css; + case user_by_cookie(Cookie) of + {ok, #user{profile = Profile}} -> + Profile#profile.css; _ -> undefined end. - - + + is_ek_master_from_cookie(Cookie) -> case user_by_cookie(Cookie) of {ok, #user{ek_master = true}} -> true; _ -> false end. - + user_by_login_password(Login, Password) -> resultat_transaction(mnesia:transaction( @@ -419,8 +247,8 @@ user_by_login_password(Login, Password) -> end end )). - - + + % Renvoie {ok, User} où User est un #user possédant le message donné. user_by_mess(Id) -> resultat_transaction(mnesia:transaction( @@ -431,20 +259,26 @@ user_by_mess(Id) -> end end )). - - + + % 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_ids) -> % regarde si les id 'Repond_A' existent - F = fun() -> - Repond_a = e( - q([M || M <- mnesia:table(minichat), lists:member(M#minichat.id, Repond_A_ids)]), - [{tmpdir, ?KEY_SORT_TEMP_DIR}] - ), + F = fun() -> + Repond_a = lists:foldr( + fun(Repond_a_id, Acc) -> + case mnesia:read({minichat, Repond_a_id}) of + [M] -> [M | Acc]; + _ -> Acc % le message n'est pas trouvé + end + end, + [], + Repond_A_ids + ), Racine_id = case Repond_a of [] -> undefined; - [M | _ ] -> + [M | _] -> Une_racine = M#minichat.racine_id, % vérification que tout les messages de Repond_a possède la même racine (même conversation) case lists:all(fun(R) -> R#minichat.racine_id =:= Une_racine end, Repond_a) of @@ -453,130 +287,116 @@ nouveau_message(Mess, Auteur_id, Repond_A_ids) -> _ -> {erreur, "Les messages ne font pas partie de la même conversation"} end - end, - case Racine_id of - {erreur, E} -> {erreur, E}; - _ -> - % est-ce que l'auteur existe ? - case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of - [Auteur] -> - if length(Repond_a) =/= length(Repond_A_ids) -> - {erreur, "Un ou plusieurs messages introuvable"}; - true -> + end, + if length(Repond_a) =/= length(Repond_A_ids) -> + {erreur, "Un ou plusieurs messages introuvable"}; + true -> + case Racine_id of + {erreur, E} -> {erreur, E}; + _ -> + % est-ce que l'auteur existe ? + case mnesia:wread({user, Auteur_id}) of + [#user{profile = Profile} = Auteur] -> % comparaison entre la date du dernier poste et maintenant (gestion du flood) - Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()), + Now = erlang:timestamp(), + Delta = euphorik_common: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() + 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 -> - mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}), - nouveau_message_sys("''" ++ Auteur#user.pseudo ++ if Auteur#user.login =/= [] -> " (" ++ Auteur#user.login ++ ")"; true -> "" end ++ "'' est bloqué pour " ++ integer_to_list(trunc(?DUREE_BLOCAGE_SPAM / 1000)) ++ " secondes pour cause de flood."); - Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM -> - {erreur, "Bloqué pour cause de flood"}; - true -> - mnesia:write(Auteur_maj), - Id = nouvel_id(minichat), - inserer_reponses(Id, Repond_A_ids), - mnesia:write(#minichat{ - id = Id, - auteur_id = Auteur#user.id, - date = now(), - pseudo = Auteur#user.pseudo, - contenu = Mess, - racine_id = if Racine_id =:= undefined -> Id; true -> Racine_id end - }), - Id - end - end; - _ -> - {erreur, "L'auteur du message est introuvable"} + mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}), + nouveau_message_sys("\"" ++ Profile#profile.pseudo ++ if Auteur#user.login =/= [] -> " (" ++ Auteur#user.login ++ ")"; true -> "" end ++ "\" est bloqué pour " ++ integer_to_list(trunc(?DUREE_BLOCAGE_SPAM / 1000)) ++ " secondes pour cause de flood."); + Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM -> + {erreur, "Bloqué pour cause de flood"}; + true -> + mnesia:write(Auteur_maj), + Id = nouvel_id(minichat), + inserer_reponses(Id, Repond_A_ids), + mnesia:write(#minichat{ + id = Id, + auteur_id = Auteur#user.id, + date = Now, + pseudo = Profile#profile.pseudo, + contenu = Mess, + racine_id = if Racine_id =:= undefined -> Id; true -> Racine_id end + }), + Id + end; + _ -> + {erreur, "L'auteur du message est introuvable"} + end end 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. - - + + % Permet de créer un message système. % Renvoie l'id du message système nouveau_message_sys(Mess) -> - nouveau_message_sys(Mess, undefined). - - -% Création d'un message système lié à un troll. -nouveau_message_sys(Mess, Troll_id) -> - {ok, Root} = user_by_id(0), + {ok, #user{profile = Profile}} = user_by_id(0), resultat_transaction(mnesia:transaction( fun() -> Id = nouvel_id(minichat), - mnesia:write(#minichat{id=Id, auteur_id=0, date=now(), pseudo=Root#user.pseudo, contenu=Mess, troll_id=Troll_id, racine_id=Id}), + mnesia:write(#minichat{id = Id, auteur_id = 0, date = erlang:timestamp(), pseudo = Profile#profile.pseudo, contenu = Mess, racine_id = Id}), Id end )). - - + + % Renvoie N messages se trouvant sur la première page -messages(N) -> +messages(N) -> messages(N, 1). % Renvoie N messages se trouvant sur la page P +% TODO FIXME : fonction en O(N * P) ! messages(N, P) -> F = fun() -> - C = cursor( - qlc:keysort( - #minichat.id, - q([E#minichat{contenu = contenu_message(E)} || E <- mnesia:table(minichat)]), - [{order, descending}] - ), - [{tmpdir, ?KEY_SORT_TEMP_DIR}] - ), - if P > 1 -> qlc:next_answers(C, N * (P - 1)); - true -> ok - end, - R = qlc:next_answers(C, N), - qlc:delete_cursor(C), - R + get_tuples(minichat, mnesia:table_info(minichat, size) - N * P + 1, N) end, - lists:reverse(resultat_transaction(mnesia:transaction(F))). + resultat_transaction(mnesia:transaction(F)). + + +get_tuples(Table, First_id, N) -> + lists:foldr( + fun(Id, Acc) -> + case mnesia:read({Table, Id}) of + [T] -> [T | Acc]; + _ -> Acc + end + end, + [], + lists:seq(First_id, First_id + N - 1) + ). % 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) -> resultat_transaction(mnesia:transaction( fun() -> case mnesia:read({minichat, Id}) of - [] -> erreur; - [M] -> - {ok, M#minichat{contenu = contenu_message(M)}} + [M] -> {ok, M}; + _ -> erreur end end )). - - -% Renvoie le contenu d'un message donnée, à utiliser à l'intérieur d'une transaction. -% TODO : Cette fonction pourrait être remplacé par un "outer-join", est-ce possible avec qlc ? -contenu_message(E) -> - case mnesia:read({troll, E#minichat.troll_id}) of - [] -> E#minichat.contenu; - [T] -> E#minichat.contenu ++ T#troll.content - end. - % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids). % TODO : optimisations ? serait-ce du O(n) ? @@ -591,7 +411,7 @@ messages_by_ids(Ids) -> ),[{tmpdir, ?KEY_SORT_TEMP_DIR}]) end )). - + % Est-ce qu'un message existe ? Renvoie un boolean. % TODO : ya pas plus simple ? @@ -599,16 +419,16 @@ message_existe(Id) -> resultat_transaction(mnesia:transaction(fun() -> length(e(q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}])) =:= 1 end)). - - + + % Renvoie les reponses (utilisé normalement uniquement pendant le debug). reponses() -> F = fun() -> e(q([E || E <- mnesia:table(reponse_minichat)]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) end, resultat_transaction(mnesia:transaction(F)). - - + + % Renvoie les messages auquel M_id répond. parents(M_id) -> resultat_transaction(mnesia:transaction( @@ -620,8 +440,8 @@ parents(M_id) -> M#minichat.id =:= R#reponse_minichat.cible]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) end )). - - + + % Renvoie les message qui repondent à M_id enfants(M_id) -> resultat_transaction(mnesia:transaction( @@ -633,68 +453,85 @@ enfants(M_id) -> M#minichat.id =:= R#reponse_minichat.repondant]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) end )). - - -% Renvoie les parents d'un message M (les messages auquels répond M) + + +% Renvoie les id des parents d'un message M (les messages auquels répond M) % ordrés du plus petit au plus grand.. +% On évite d'utiliser qlc pour des raisons de performance % @spec parents_id(integer()) -> [integer()] -parents_id(M) -> +parents_id(M_id) -> resultat_transaction(mnesia:transaction(fun() -> - e( - qlc:sort( - q([E#reponse_minichat.cible || E <- mnesia:table(reponse_minichat), E#reponse_minichat.repondant =:= M]), - [{order, ascending}] - ), - [{tmpdir, ?KEY_SORT_TEMP_DIR}] - ) + case mnesia:read({reponse_minichat, M_id}) of + Parents when is_list(Parents) -> + lists:sort(lists:map( + fun(#reponse_minichat{cible = Cible}) -> Cible end, + Parents + )); + _ -> [] + end end)). - - + + % Renvoie les id des enfants d'un message M (les messages qui répondent à M) % ordrés du plus petit au plus grand. % @spec enfants_id(integer()) -> [integer()] -enfants_id(M) -> +enfants_id(M_id) -> resultat_transaction(mnesia:transaction(fun() -> - e( - qlc:sort( - q([E#reponse_minichat.repondant || E <- mnesia:table(reponse_minichat), E#reponse_minichat.cible =:= M]), - [{order, ascending}] - ), - [{tmpdir, ?KEY_SORT_TEMP_DIR}] - ) + case mnesia:index_read(reponse_minichat, M_id, #reponse_minichat.cible) of + Enfants when is_list(Enfants) -> + lists:sort(lists:map( + fun(#reponse_minichat{repondant = Repondant}) -> Repondant end, + Enfants + )); + _ -> [] + end end)). - + % Est-ce que le message Id_mess est une réponse d'une message de Id_user ? +% On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance. est_une_reponse_a_user(Id_user, Id_mess) -> - case mnesia:transaction( - fun() -> - e(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}, {tmpdir, ?KEY_SORT_TEMP_DIR}]) - end - ) of - {atomic, [_]} -> true; - _ -> false - end. + resultat_transaction(mnesia:transaction( + fun() -> + case mnesia:read({reponse_minichat, Id_mess}) of + [] -> false; + Cibles -> + lists:any( + fun(#reponse_minichat{cible = Cible}) -> + case mnesia:read({minichat, Cible}) of + [#minichat{auteur_id = Id_user}] -> true; + _ -> false + end + end, + Cibles + ) + end + end + )). + - % Est-ce que Id_user à répondu au message Id_mess +% On evite d'utiliser qlc (ce qui était fait avant) pour des raisons de performance. a_repondu_a_message(Id_user, Id_mess) -> - case mnesia:transaction( - fun() -> - e(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}, {tmpdir, ?KEY_SORT_TEMP_DIR}]) - end - ) of - {atomic, [_]} -> true; - _ -> false - end. - - + resultat_transaction(mnesia:transaction( + fun() -> + case mnesia:index_read(reponse_minichat, Id_mess, #reponse_minichat.cible) of + [] -> false; + Reponses -> + lists:any( + fun(#reponse_minichat{repondant = Reponse}) -> + case mnesia:read({minichat, Reponse}) of + [#minichat{auteur_id = Id_user}] -> true; + _ -> false + end + end, + Reponses + ) + end + end + )). + + % Est-ce que Id_user possède Id_mess ? possede_message(Id_user, Id_mess) -> case mnesia:transaction( @@ -705,20 +542,20 @@ possede_message(Id_user, Id_mess) -> {atomic, [Id_user | []]} -> true; _ -> false end. - - + + % renvoie la liste des ip bannies % liste de {ip, temps_restant(en minutes), Users} ou Users est une liste de {pseudo, login} % TODO : déterminer la complexité de cette fonction. (Il n'y a pas d'index sur #user.last_ip) list_ban() -> resultat_transaction(mnesia:transaction( fun() -> - Now = now(), + Now = erlang:timestamp(), e(qlc:keysort(1, q([ { IP#ip_table.ip, - delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now), - e(q([{U#user.pseudo, U#user.login} || U <- mnesia:table(user), U#user.last_ip =:= IP#ip_table.ip]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) + euphorik_common:delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now), + e(q([{Profile#profile.pseudo, U#user.login} || #user{profile = Profile} = U <- mnesia:table(user), U#user.last_ip =:= IP#ip_table.ip]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) } || IP <- mnesia:table(ip_table), if IP#ip_table.ban =:= undefined -> false; true -> date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration) > Now end @@ -733,19 +570,19 @@ ban(IP, Duration) -> fun() -> case mnesia:wread({ip_table, IP}) of [IP_tuple] -> - mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration}); + mnesia:write(IP_tuple#ip_table{ban = erlang:timestamp(), ban_duration = Duration}); _ -> - mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration}) + mnesia:write(#ip_table{ip = IP, ban = erlang:timestamp(), ban_duration = Duration}) end end ). - + % Débanni une ip deban(IP) -> ban(IP, 0). - + % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni % ou false. est_banni(User_id) -> @@ -760,46 +597,46 @@ est_banni(User_id) -> ]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of [{Ban, Ban_duration}] -> Echeance = date_plus_minutes(Ban, Ban_duration), - Now = now(), + Now = erlang:timestamp(), if Echeance < Now -> % l'échéance est passée false; true -> - {true, delta_date_minute(Echeance, Now)} + {true, euphorik_common:delta_date_minute(Echeance, Now)} end; _ -> false end end )). - - -% Ban est une date tel que retourner par now(). + + +% Ban est une date tel que retourner par erlang:timestamp(). % Ban_duration est un temps en minutes. % retourne une date. date_plus_minutes(Ban, Ban_duration) -> Duration_sec = Ban_duration * 60, {MegaSec, Sec, MicroSec} = Ban, {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}. - -% Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors + +% 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 e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of - [] -> - mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}), + [] -> + mnesia:write(#ip_table{ip = IP, date_last_try_register = erlang:timestamp()}), true; [T] -> - Delta = delta_date_ms(T#ip_table.date_last_try_register, now()), + Delta = euphorik_common:delta_date_ms(T#ip_table.date_last_try_register, erlang:timestamp()), if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER -> false; true -> - mnesia:write(#ip_table{ + mnesia:write(T#ip_table{ ip = IP, - date_last_try_register = now(), + date_last_try_register = erlang:timestamp(), 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 @@ -807,172 +644,13 @@ can_register(IP) -> end end )). - - -% Renvoie tous les trolls -trolls() -> - resultat_transaction(mnesia:transaction( - fun() -> - e(qlc:keysort(#troll.id, q([T || T <- mnesia:table(troll)])), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) - end - )). - - -% Renvoie les trolls manquants posté après Last_id. -trolls(Last_id) -> - resultat_transaction(mnesia:transaction( - fun() -> - e(qlc:keysort(#troll.id, q([T || T <- mnesia:table(troll), T#troll.id > Last_id, T#troll.date_post =:= undefined])), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) - end - )). - - - % Crée un nouveau troll. - % Renvoie l'id du nouveau troll - % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind - % ou max_troll_reached si le nombre de troll posté max a été atteind - % ou user_unknown -put_troll(User_id, Content) -> - resultat_transaction(mnesia:transaction( - fun() -> - % control le nombre de troll déjà posté - Nb_troll_poste_par_user = length(e(q( - [ - E#troll.id || E <- mnesia:table(troll), - E#troll.id_user =:= User_id, - E#troll.date_post =:= undefined - ] - ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])), - Nb_troll_poste_total = length(e(q( - [ - E#troll.id || E <- mnesia:table(troll), - E#troll.date_post =:= undefined - ] - ), [{tmpdir, ?KEY_SORT_TEMP_DIR}])), - User = user_by_id(User_id), - case User of - {ok, _} -> - if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER -> - max_troll_reached_per_user; - Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING -> - max_troll_reached; - true -> - Id = nouvel_id(minichat), - mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}), - Id - end; - _ -> - user_unknown - end - end - )). - - -% renvoie ok | erreur -mod_troll(Troll_id, Content) -> - mnesia:transaction( - fun() -> - case mnesia:wread({troll, Troll_id}) of - [Troll = #troll{date_post = undefined}] -> - mnesia:write(Troll#troll{content = Content}); - _ -> - mnesia:abort("mod_troll: Troll inconnu ou déjà posté") - end - end - ). - - -del_troll(Troll_id) -> - mnesia:transaction( - fun() -> - case mnesia:wread({troll, Troll_id}) of - [#troll{date_post = undefined}] -> - mnesia:delete({troll, Troll_id}); - _ -> - mnesia:abort("mod_troll: Troll inconnu ou déjà posté") - end - end - ). - - -troll_by_id(Troll_id) -> - resultat_transaction(mnesia:transaction( - fun() -> - case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of - [T] -> {ok, T}; - _ -> - erreur - end - end - )). - - -% Renvoie le troll actuel qui se trouve sur la page principale. -% Renvois aucun si pas de troll courant. -current_troll() -> - resultat_transaction(mnesia:transaction( - fun() -> - C = cursor(qlc:keysort(#troll.date_post, q([T || T <- mnesia:table(troll), T#troll.date_post =/= undefined]), [{order, descending}]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]), - R = case qlc:next_answers(C, 1) of - [T] -> T; - _ -> aucun - end, - qlc:delete_cursor(C), - R - end - )). - - -% Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined) -% Un message est posté par 'Sys' et le troll elu est lié à ce message -% met à jour sa date de post. -% renvoie plus_de_trolls si il n'y a aucun troll en attente. -elire_troll() -> - {A1,A2,A3} = now(), - random:seed(A1, A2, A3), - mnesia:transaction( - fun() -> - case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of - [] -> - plus_de_trolls; - Trolls -> - Troll = lists:nth(random:uniform(length(Trolls)), Trolls), - Troll2 = Troll#troll{date_post = now()}, - mnesia:write(Troll2), - nouveau_message_sys("Troll de la semaine : ", Troll2#troll.id) - end - end - ). - -% Renvoie l'id du message associé au troll dont l'id est donnée. -% Renvoie undefined si il n'y en a pas. -message_id_associe(Troll_id) -> - resultat_transaction(mnesia:transaction( - fun() -> - case e(q([M#minichat.id || M <- mnesia:table(minichat), M#minichat.troll_id =:= Troll_id]), [{tmpdir, ?KEY_SORT_TEMP_DIR}]) of - [Id] -> Id; - _ -> undefined - 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). - -% Retourne la différence entre deux timestamp (erlang:now) en minutes -delta_date_minute(D1, D2) -> - trunc(delta_date_ms(D1, D2) / 1000 / 60). % 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