X-Git-Url: http://git.euphorik.ch/?p=euphorik.git;a=blobdiff_plain;f=modules%2Ferl%2Feuphorik_protocole.erl;h=82a4fce42977d19a82e162290e399479019fa9f3;hp=448a20b9ea3d41ba27c8e3e19baea1002e0953f6;hb=c219198926b679ef5bc28182b3d05e8c1f447886;hpb=c01d54fd6a515a6f2860e3b18ff574afa5caa83b

diff --git a/modules/erl/euphorik_protocole.erl b/modules/erl/euphorik_protocole.erl
index 448a20b..82a4fce 100755
--- a/modules/erl/euphorik_protocole.erl
+++ b/modules/erl/euphorik_protocole.erl
@@ -25,7 +25,6 @@
 -export([
    register/2,
    login/2,
-   logout/1,
    profile/1,
    wait_event/1,
    put_message/1,
@@ -43,14 +42,14 @@
 
 
 % Une utilisateur s'enregistre avec un tuple {Login, Password}.
-register([{login, Login}, {password, Password}], IP) ->
+register([{login, Login}, {password, Password}, {profile, Profile_json}], IP) ->
    Can_register = euphorik_bd:can_register(IP),
    if Can_register ->
          case euphorik_bd:user_by_login(Login) of
             {ok, _} ->
-               erreur("Login déjà existant");
+               erreur(10);
             _ ->
-               User = euphorik_bd:nouveau_user(Login, Password, generer_cookie()),
+               User = euphorik_bd:nouveau_user(Login, Password, generer_cookie(), profile_from_json(Profile_json)),
                euphorik_bd:update_ip(User#user.id, IP),
                json_reponse_login_ok(User)
          end;
@@ -58,10 +57,11 @@ register([{login, Login}, {password, Password}], IP) ->
          erreur_register_flood()
    end;
 % Enregistrement sans {Login, Password}
-register([], IP) ->   
+register([{profile, Profile_json}], IP) ->   
    Can_register = euphorik_bd:can_register(IP),
    if Can_register ->
-         User = euphorik_bd:nouveau_user("<nick>", generer_cookie()),
+         Profile = profile_from_json(Profile_json),
+         User = euphorik_bd:nouveau_user(generer_cookie(), Profile#profile{pseudo = "<nick>"}),
          euphorik_bd:update_ip(User#user.id, IP),
          json_reponse_login_ok(User);
       true ->
@@ -69,24 +69,34 @@ register([], IP) ->
    end.
    
 erreur_register_flood() ->
-   erreur("Trop de register (flood)").
+   erreur(20).
    
 
 % Un utilisateur se logge (avec un couple {login, mot de passe})
 login([{login, Login}, {password, Password}], IP) ->
-   loginUser(euphorik_bd:user_by_login_password(Login, Password), IP);
+   case euphorik_bd:user_by_login_password(Login, Password) of
+      {ok, User} ->
+         loginUser(User, IP);
+      _ -> 
+         timer:sleep(?TEMPS_ATTENTE_ERREUR_LOGIN),
+         erreur(30)
+   end;
 % Un utilisateur se logge (avec un cookie)
 login([{cookie, Cookie}], IP) ->
-   loginUser(euphorik_bd:user_by_cookie(Cookie), IP).
+   case euphorik_bd:user_by_cookie(Cookie) of
+      {ok, User} ->
+         loginUser(User, IP);
+      _ ->
+         timer:sleep(?TEMPS_ATTENTE_ERREUR_LOGIN),
+         erreur(40)
+   end.
+   
    
-loginUser({ok, User}, IP) ->
+% L'utilisateur donné se logge avec l'ip donnée.
+loginUser(User, IP) ->
    euphorik_bd:update_ip(User#user.id, IP),
    euphorik_bd:update_date_derniere_connexion(User#user.id),
-   json_reponse_login_ok(User);
-loginUser(_, _) ->
-   % ajoute un délais d'attente
-   timer:sleep(?TEMPS_ATTENTE_ERREUR_LOGIN),
-   erreur("Couple login/pass introuvable").
+   json_reponse_login_ok(User).
    
    
 % Renvoie un string() représentant un cookie en base 36. Il y a 10^32 possibillités.
@@ -96,55 +106,92 @@ generer_cookie() ->
    erlang:integer_to_list(random:uniform(math:pow(10, 32)), 36).
 
 
-% Un utilisateur se délogge.
-logout(_) ->
-   do_nothing.
-
-
 % Modification du profile.
 profile(
    [
       {cookie, Cookie},
       {login, Login},
       {password, Password},
-      {nick, Pseudo},
-      {email, Email},
-      {css, Css},
-      {nick_format, Nick_format_str},
-      {view_times, View_times},
-      {view_tooltips, View_tooltips},
-      {conversations, {array, Conversations_json}}
+      {profile, Profile_json}
    ]
 ) ->
-   % virage des messages qui n'existent pas
-   Conversations = lists:dropwhile(
-      fun(Message_id) ->
-         not euphorik_bd:message_existe(Message_id)
+   case profile_from_json(Profile_json) of
+      {erreur, E} -> E;
+      Profile ->
+         case euphorik_bd:set_profile(Cookie, Login, Password, Profile) of
+            ok ->
+               json_reponse_ok();
+            login_deja_pris ->
+               erreur(10);
+            _ ->
+               erreur(50)
+         end
+   end.
+
+
+% Construit un #user à partir des données JSON
+profile_from_json(
+   {struct,
+      [
+         {nick, Pseudo},
+         {email, Email},
+         {css, Css},
+         {chat_order, Chat_order_str},
+         {nick_format, Nick_format_str},
+         {view_times, View_times},
+         {view_tooltips, View_tooltips},
+         {conversations, {array, Conversations_json}},
+         {ostentatious_master, Ostentatious_master_str}
+      ]
+   }
+) ->
+   % décomposition de la strucure JSON
+   Conversations = lists:foldr(
+      fun({struct, [{root, Racine}, {minimized, Reduit}]}, A) ->
+         % virage des messages qui n'existent pas
+         Message_exite = euphorik_bd:message_existe(Racine),
+         if Message_exite ->
+               [ {Racine, Reduit} | A];
+            true ->
+               A
+         end
       end,
+      [],
       Conversations_json
    ),
-   %  TODO : pas très beau, mieux vaut construire un #user
-   case euphorik_bd:set_profile(
-         Cookie,
-         Login,
-         Password,
-         Pseudo,
-         Email,
-         Css,
-         list_to_atom(Nick_format_str),
-         View_times,
-         View_tooltips,
-         Conversations) of
-      ok ->
-         json_reponse_ok();
-      login_deja_pris ->
-         erreur("Login déjà pris");
-      _ ->
-         erreur("Impossible de mettre à jour le profile")
+   % vérification des données JSON
+   Chat_order = list_to_atom(Chat_order_str),
+   Chat_order_valide = lists:any(fun(E) -> E =:= Chat_order end, [reverse, chrono]),
+   if not Chat_order_valide ->
+         {erreur, Chat_order_str ++ " n'est pas une valeur acceptée pour 'chat_order'"};
+      true -> 
+         Nick_format = list_to_atom(Nick_format_str),
+         Nick_format_valide = lists:any(fun(E) -> E =:= Nick_format end, [nick, login, nick_login]),
+         if not Nick_format_valide ->
+               {erreur, Nick_format_str ++ " n'est pas une valeur acceptée pour 'nick_format'"};
+            true -> 
+               Ostentatious_master = list_to_atom(Ostentatious_master_str),
+               Ostentatious_master_valide = lists:any(fun(E) -> E =:= Ostentatious_master end, [invisible, light, heavy]),
+               if not Ostentatious_master_valide ->
+                     {erreur, Ostentatious_master_str ++ " n'est pas une valeur acceptée pour 'ostentatious_master'"};
+                  true ->
+                     #profile{
+                        pseudo = Pseudo,
+                        email = Email,
+                        css = Css,
+                        chat_order = Chat_order,
+                        nick_format = Nick_format,
+                        view_times = View_times,
+                        view_tooltips = View_tooltips,
+                        conversations = Conversations,
+                        ostentatious_master = Ostentatious_master
+                     }
+               end
+         end      
    end.
 
 
-% Renvoie les messages appropriés.
+% Attend un événement pour la page "Chat"
 % last_message id et cookie sont facultatifs
 wait_event([{page, "chat"} | Data]) ->
    % traitement des inputs
@@ -175,6 +222,7 @@ wait_event([{page, "chat"} | Data]) ->
          mnesia:unsubscribe({table, troll, detailed}),
          R
    end;
+% Attend un événement pour la page "Admin"
 wait_event([{page, "admin"}, {last_troll, Last_troll}]) ->
    case wait_event_page_admin(Last_troll) of
       banned_ips_refresh ->
@@ -198,12 +246,12 @@ wait_event([{page, "admin"}, {last_troll, Last_troll}]) ->
                {trolls, {array, 
                   lists:map(
                      fun(T) ->                        
-                        {ok, User} = euphorik_bd:user_by_id(T#troll.id_user),
+                        {ok, #user{profile = Profile} = User} = euphorik_bd:user_by_id(T#troll.id_user),
                         {struct,
                            [
                               {troll_id, T#troll.id},
                               {content, T#troll.content},
-                              {author, User#user.pseudo},
+                              {author, Profile#profile.pseudo},
                               {author_id, User#user.id}
                            ]
                         }
@@ -221,12 +269,13 @@ wait_event([{page, "admin"}, {last_troll, Last_troll}]) ->
             ]
          };                  
       _ ->
-         erreur("timeout")
+         erreur(60)
    end;
 wait_event(_) ->
-   erreur("Page inconnue").
+   erreur(70).
 
 
+% Attend un événement pour la page "Chat" et renvoie soit un troll soit les messages manquants au client.
 wait_event_page_chat(User, Racines_conversations, Message_count, Last_message_id, Main_page, Troll_id) ->
    % est-ce que le troll est à jour ?
    case euphorik_bd:current_troll() of
@@ -249,50 +298,48 @@ wait_event_page_chat(User, Racines_conversations, Message_count, Last_message_id
                   {reply, "new_messages"},
                   {conversations, {array,
                      lists:map(
-                        fun({Conv, Plus}) ->
+                        fun({Racine, {Conv, Plus}}) ->
                            {struct, [
                               {last_page, not Plus},
-                              {messages, {array, 
+                              {first, % le premier message de la conversation
+                                 if Racine =:= undefined orelse Conv =:= [] ->
+                                       null;
+                                    true ->
+                                       {Racine_id, _, _} = Racine,
+                                       case euphorik_bd:message_by_id(Racine_id) of
+                                          {ok, Mess} ->
+                                             json_message(Mess, euphorik_bd:parents(Racine), User);
+                                          _ ->
+                                             null
+                                       end
+                                 end
+                              },
+                              {messages, {array,
                                  lists:map(
-                                    fun({Mess, Repond_a}) ->                                 
-                                       Est_proprietaire = User =/= inconnu andalso User#user.id =:= Mess#minichat.auteur_id,
-                                       A_repondu_a_message = User =/= inconnu andalso euphorik_bd:a_repondu_a_message(User#user.id, Mess#minichat.id),
-                                       Est_une_reponse_a_user = User =/= inconnu andalso euphorik_bd:est_une_reponse_a_user(User#user.id, Mess#minichat.id),
-                                       {ok, User_mess } = euphorik_bd:user_by_id(Mess#minichat.auteur_id),
-                                       {struct, [
-                                          {id, Mess#minichat.id},
-                                          {user_id, User_mess#user.id},
-                                          {date, format_date(Mess#minichat.date)},
-                                          {system, Mess#minichat.auteur_id =:= 0},
-                                          {owner, Est_proprietaire},
-                                          {answered, A_repondu_a_message},
-                                          {is_a_reply, Est_une_reponse_a_user},
-                                          {nick, Mess#minichat.pseudo},
-                                          {login, User_mess#user.login},
-                                          {content, Mess#minichat.contenu},
-                                          {root, Mess#minichat.racine_id},
-                                          {answer_to, {array, lists:map(
-                                             fun(Id_mess) ->                   
-                                                {ok, M} = euphorik_bd:message_by_id(Id_mess),
-                                                {ok, User_reponse} = euphorik_bd:user_by_mess(M#minichat.id),
-                                                {struct, [{id, M#minichat.id}, {nick, M#minichat.pseudo}, {login, User_reponse#user.login}]}
-                                             end,
-                                             Repond_a
-                                          )}},
-                                          {ek_master, User_mess#user.ek_master}
-                                       ]}
+                                    fun({Mess, Repond_a}) ->
+                                       json_message(Mess, Repond_a, User)
                                     end,
                                     Conv
                                  )
                               }}
                            ]}
                         end,
-                        Conversations
+                        % on ajoute un 'undefined' correspondant à la premier conversation qui ne possède pas de racine
+                        % TODO : peut être à revoir car un peu lourd est compliqué
+                        aggregation_racines_conversations([undefined | Racines_conversations], Conversations)
                      )
                   }}
                ]}
          end
    end.
+   
+
+aggregation_racines_conversations(L1, L2) -> 
+   aggregation_racines_conversations(L1, L2, []).
+aggregation_racines_conversations([], [], L) -> lists:reverse(L);
+aggregation_racines_conversations([E1|R1], [E2|R2], L) ->
+   aggregation_racines_conversations(R1, R2, [{E1, E2} | L]).
+   
 
 
 % Attend un événement lié à la page 'chat'.
@@ -379,23 +426,23 @@ put_message(
       {ok, User} ->
          case euphorik_bd:est_banni(User#user.id) of
             {true, Temps_restant} ->
-               erreur("Vous êtes banni pour encore " ++ format_minutes(Temps_restant));
+               erreur(80, format_minutes(Temps_restant));
             _ ->
                Strip_content = string:strip(Content),
                if Strip_content =:= [] ->
-                     erreur("Message vide");
+                     erreur(90);
                   true ->
                      % attention : non-atomique (update_pseudo+nouveau_message)
                      euphorik_bd:update_pseudo_user(User#user.id, Nick),
                      case euphorik_bd:nouveau_message(Strip_content, User#user.id, Answer_to) of
-                        {erreur, R} -> erreur("Impossible d'ajouter un nouveau message. Raison : " ++ R);
+                        {erreur, R} -> erreur(100, R);
                         _ ->
                            json_reponse_ok()
                      end
                end
          end;
    _ ->
-      erreur("Utilisateur inconnu")
+      erreur(110)
    end.
 
 
@@ -412,12 +459,12 @@ ban(
          {ok, User1 = #user{ek_master = true}} ->
             case euphorik_bd:user_by_id(User_id) of
                {ok, User1} ->
-                  erreur("Il n'est pas possible de s'auto bannir");
-               {ok, User2 = #user{ek_master = false}} ->
+                  erreur(120);
+               {ok, #user{ek_master = false, profile = Profile2} = User2} ->
                   euphorik_bd:ban(User2#user.last_ip, Duration),
                   euphorik_bd:nouveau_message_sys(lists:flatten(io_lib:format("''~s~s'' est ~s pour ~s.~s",
                      [
-                        User2#user.pseudo,
+                        Profile2#profile.pseudo,
                         if User2#user.login =:= [] -> ""; true -> " (" ++ User2#user.login ++ ")" end,
                         if Duration =< 15 -> "kické"; true -> "banni" end,
                         format_minutes(Duration),
@@ -426,12 +473,12 @@ ban(
                   ))),
                   json_reponse_ok();
                {ok, _} ->
-                  erreur("L'utilisateur est lui même un ekMaster");
+                  erreur(130);
                _ ->
-                  erreur("Utilisateur à bannir inconnu")
+                  erreur(140)
             end;
          _ ->
-            erreur("Utilisateur inconnu ou non ek master")
+            erreur(150)
       end.
       
 
@@ -444,32 +491,32 @@ slap(
    ]) ->
       % controle que l'utilisateur est un admin
       case euphorik_bd:user_by_cookie(Cookie) of
-         {ok, User1 = #user{ek_master = true}} ->
+         {ok, User1 = #user{ek_master = true, profile = Profile1}} ->
             case euphorik_bd:user_by_id(User_id) of
                {ok, User1} ->
                   euphorik_bd:nouveau_message_sys(lists:flatten(io_lib:format("~s s'auto slap~s.", 
                      [
-                        User1#user.pseudo,
+                        Profile1#profile.pseudo,
                         if Reason =/= [] -> " - Raison: " ++ Reason; true -> "" end
                      ]
                   ))),
                   json_reponse_ok();
-               {ok, User2 = #user{ek_master = false}} ->
+               {ok, #user{ek_master = false, profile = Profile2}} ->
                   euphorik_bd:nouveau_message_sys(lists:flatten(io_lib:format("~s se fait slaper par ~s.~s",
                      [
-                        User2#user.pseudo,
-                        User1#user.pseudo,
+                        Profile2#profile.pseudo,
+                        Profile1#profile.pseudo,
                         if Reason =/= [] -> " - Raison: " ++ Reason; true -> "" end ++ "."
                      ]
                   ))),
                   json_reponse_ok();
                {ok, _} ->
-                  erreur("L'utilisateur est lui même un ekMaster");
+                  erreur(130);
                _ ->
-                  erreur("Utilisateur à slaper inconnu")
+                  erreur(160)
             end;
          _ ->
-            erreur("Utilisateur inconnu ou non ek master")
+            erreur(170)
       end.
       
  
@@ -484,14 +531,14 @@ put_troll(
       {ok, User = #user{ek_master = true}} ->
          case euphorik_bd:put_troll(User#user.id, Content) of
             max_troll_reached_per_user ->
-               erreur(lists:flatten(io_lib:format("Le nombre de troll maximum par utilisateur est atteint : ~w ", [?NB_MAX_TROLL_WAITING_BY_USER])));
+               erreur(180, ?NB_MAX_TROLL_WAITING_BY_USER);
             max_troll_reached ->
-               erreur(lists:flatten(io_lib:format("Le nombre de troll maximum en attente est atteint : ~w ", [?NB_MAX_TROLL_WAITING])));
+               erreur(190, ?NB_MAX_TROLL_WAITING);
             _Id ->
                json_reponse_ok()
          end;
       _ ->
-         erreur("Seul les ekMaster peuvent proposer des trolls")
+         erreur(200)
    end.
    
    
@@ -511,10 +558,10 @@ mod_troll(
                euphorik_bd:mod_troll(Troll_id, Content),
                json_reponse_ok();
             _ ->
-               erreur("Vous ne posséder pas ce troll")
+               erreur(210)
          end;
       _ ->
-         erreur("Seul les ekMaster peuvent proposer des trolls")
+         erreur(220)
       end.
 
    
@@ -533,10 +580,10 @@ del_troll(
                euphorik_bd:del_troll(Troll_id),
                json_reponse_ok();
             _ ->
-               erreur("Vous ne posséder pas ce troll")
+               erreur(210)
          end;
       _ ->
-         erreur("Seul les ekMaster peuvent proposer des trolls")
+         erreur(220)
    end.
    
    
@@ -551,7 +598,7 @@ unban_ip(
          euphorik_bd:deban(euphorik_common:unserialize_ip(IP)),
          json_reponse_ok();
       _ ->
-         erreur("Seul les ekMaster peuvent connaitre la liste des ips bannies")
+         erreur(230)
    end.
    
    
@@ -591,16 +638,25 @@ list_banned_ips(
             ]
          };
       _ ->
-         erreur("Seul les ekMaster peuvent connaitre la liste des ips bannies")
+         erreur(230)
    end.
 
 
 % Construit une erreur
-erreur(Message) ->
+erreur(Num, Args) ->
+   erreur_json(Num, lists:flatten(io_lib:format(euphorik_bd:get_texte(Num), Args))).
+   
+   
+erreur(Num) ->
+   erreur_json(Num, euphorik_bd:get_texte(Num)).
+   
+   
+erreur_json(Num, Mess) ->
    {
       struct, [
          {reply, "error"},
-         {error_message, Message}
+         {no, Num},
+         {error_message, Mess}
       ]
    }.
    
@@ -646,21 +702,65 @@ json_reponse_ok() ->
    {struct, [{reply, "ok"}]}.
    
    
-json_reponse_login_ok(User) ->
+json_reponse_login_ok(#user{profile = Profile} = User) ->
    {
       struct, [
          {reply, "login"},
          {status, if (User#user.password =/= []) and (User#user.login =/= []) -> "auth_registered"; true -> "auth_not_registered" end},
          {cookie, User#user.cookie},
          {id, User#user.id},
-         {nick, User#user.pseudo},
          {login, User#user.login},
-         {email, User#user.email},
-         {css, User#user.css},
-         {nick_format, atom_to_list(User#user.nick_format)},
-         {view_times, User#user.view_times},
-         {view_tooltips, User#user.view_tooltips},
-         {conversations, {array, User#user.conversations } },
-         {ek_master, User#user.ek_master}
+         {ek_master, User#user.ek_master},
+         {profile, {struct,
+            [
+               {nick, Profile#profile.pseudo},
+               {email, Profile#profile.email},
+               {css, Profile#profile.css},
+               {chat_order, atom_to_list(Profile#profile.chat_order)},
+               {nick_format, atom_to_list(Profile#profile.nick_format)},
+               {view_times, Profile#profile.view_times},
+               {view_tooltips, Profile#profile.view_tooltips},
+               {conversations, {array, lists:map(
+                  fun({Racine, Reduit}) ->
+                     {struct, [{root, Racine}, {minimized, Reduit}]}
+                  end,
+                  Profile#profile.conversations
+               )}},
+               {ostentatious_master, atom_to_list(Profile#profile.ostentatious_master)}
+            ]
+         }}
       ]
    }.
+   
+% Renvoie le message formaté en JSON.
+% Mess est de type #minichat
+% Repond_a est une liste d'id des messages auquel répond Mess
+% User est l'utilisateur courant de type #user
+json_message(Mess, Repond_a, User) ->
+   Est_proprietaire = User =/= inconnu andalso User#user.id =:= Mess#minichat.auteur_id,
+   A_repondu_a_message = User =/= inconnu andalso euphorik_bd:a_repondu_a_message(User#user.id, Mess#minichat.id),
+   Est_une_reponse_a_user = User =/= inconnu andalso euphorik_bd:est_une_reponse_a_user(User#user.id, Mess#minichat.id),
+   {ok,  #user{profile = Profile_mess} = User_mess } = euphorik_bd:user_by_id(Mess#minichat.auteur_id),
+   {struct, [
+      {id, Mess#minichat.id},
+      {user_id, User_mess#user.id},
+      {date, format_date(Mess#minichat.date)},
+      {system, Mess#minichat.auteur_id =:= 0},
+      {owner, Est_proprietaire},
+      {answered, A_repondu_a_message},
+      {is_a_reply, Est_une_reponse_a_user},
+      {nick, Mess#minichat.pseudo},
+      {login, User_mess#user.login},
+      {content, Mess#minichat.contenu},
+      {root, Mess#minichat.racine_id},
+      {answer_to, {array, lists:map(
+         fun(Id_mess) ->                   
+            {ok, M} = euphorik_bd:message_by_id(Id_mess),
+            {ok, User_reponse} = euphorik_bd:user_by_mess(M#minichat.id),
+            {struct, [{id, M#minichat.id}, {nick, M#minichat.pseudo}, {login, User_reponse#user.login}]}
+         end,
+         Repond_a
+      )}},
+      {ek_master, User_mess#user.ek_master},
+      {ostentatious_master, atom_to_list(Profile_mess#profile.ostentatious_master)}
+   ]}.