modules/erl/euphorik_protocole.erl

   1 % coding: utf-8
   2 % Ce module gére les différents message envoyé par le client (javascript) via AJAX.
   3 % Par exemple le client peut demander les derniers messages du minichat.
   4 % Les messages sont au format XML, la plus part des fonctions accepte un xmlDocument() et renvoie un string()
   5 % qui est la réponse XML.
   6 % Example XML : http://www.erlang.org/doc/apps/xmerl/xmerl_ug.html.
   7 % @author G.Burri
   8
   9 -module(euphorik_protocole).
  10 -export([
  11    nouveau_user_login/1,
  12    login/1,
  13    logout/1,
  14    profile/1,
  15    refreshMessage/1,
  16    message/1,
  17    erreur/1
  18 ]).
  19
  20 -include_lib("xmerl/include/xmerl.hrl").
  21 -include("../include/euphorik_bd.hrl").
  22 -include("../include/euphorik_defines.hrl").
  23
  24
  25 % Une utilisateur s'enregistre avec un tuple {Login, Password}.
  26 register([]) ->
  27    {Login, Password, Login_deja_pris} = case {xmerl_xpath:string("login", Action), xmerl_xpath:string("password", Action)} of
  28       {[#xmlElement{content = [#xmlText{value = L}]}], [#xmlElement{content = [#xmlText{value = P}]}]} ->
  29          {L, P, case euphorik_minichat:user_by_login(L) of {ok, _} -> true; _ -> false end};
  30       _ -> {[], [], false}
  31    end,
  32    simple_xml_to_string(
  33       if Login_deja_pris->
  34             xml_reponse_login_pas_ok("Login déjà pris");
  35          true ->
  36             Cookie = generer_cookie(),
  37             User = euphorik_minichat:nouveau_user(Login, Password, Cookie),
  38             xml_reponse_login_ok(User)
  39       end
  40    ).
  41
  42
  43 % Un utilisateur se logge (avec un couple {login, mot de passe})
  44 login([{login, Login}, {password, Password}]) ->
  45    loginUser(euphorik_minichat:user_by_login_password(Login, Password));
  46 % Un utilisateur se logge (avec un cookie)
  47 login([{cookie, Cookie}]) ->
  48    loginUser(euphorik_minichat:user_by_cookie(Cookie)).
  49
  50 loginUser({ok, User}) ->
  51    euphorik_minichat:update_date_derniere_connexion(User#user.id),
  52    json_reponse_login_ok(User);
  53 loginUser(_) ->
  54    erreur("Erreur login").
  55
  56
  57 % Renvoie un string() représentant un cookie en base 36. Il y a 10^32 possibillités.
  58 generer_cookie() ->
  59    {A1,A2,A3} = now(),
  60    random:seed(A1, A2, A3),
  61    erlang:integer_to_list(random:uniform(math:pow(10, 32)), 36).
  62
  63
  64 % Un utilisateur se délogge.
  65 logout(_) ->
  66    do_nothing.
  67
  68
  69 % Modification du profile.
  70 profile(
  71    [
  72       {cookie, Cookie},
  73       {login, Login},
  74       {password, Password},
  75       {pseudo, Pseudo},
  76       {email, Email},
  77       {css, Css},
  78       {main_page, Main_page},
  79       {conversations, {array, Conversations_json}}
  80    ]
  81 ) ->
  82    % est-ce que les messages auquel on répond existent ?
  83    Conversations = lists:foldr(
  84       fun([struct, {root, Root}, {page, Page}], Acc) ->
  85          Message_existe = euphorik_minichat:message_existe(Root),
  86          if  Message_existe ->
  87             [{Root, Page} | Acc];
  88          true ->
  89             Acc
  90       end,
  91       [],
  92       Conversations_json
  93    ),
  94    case euphorik_minichat:set_profile(Cookie, Login, Password, Pseudo, Email, Css, Main_page, Conversations) of
  95       ok ->
  96          json_reponse_ok();
  97       login_deja_pris ->
  98          erreur("Login déjà pris");
  99       _ ->
 100          erreur("Impossible de mettre à jour le profile")
 101    end.
 102
 103
 104 % Renvoie les messages appropriés.
 105 wait_event(
 106    [
 107       {cookie, Cookie},
 108       {message_count, Message_count} | Reste
 109    ]
 110 ) ->
 111    % Last message id est facultatif
 112    Last_message_id = case lists:keysearch(last_message_id, 1, Reste) of
 113       {Id, _} -> Id;
 114       _ -> 0
 115    end,
 116    {Main_page, _} = lists:keysearch(main_page, 1, Reste),
 117    {{array, Conversations_json}, _} = lists:keysearch(conversations, 1, Reste),
 118    User = euphorik_minichat:user_by_cookie(Cookie),
 119
 120
 121    % TODO....
 122
 123
 124
 125    simple_xml_to_string(
 126       case xmerl_xpath:string("nombreMessage", Action) of % le nombre de message qu'affiche le client
 127          [#xmlElement{content = [#xmlText{value = Nb_message_str}]}] ->
 128             Nb_message = list_to_integer(Nb_message_str),
 129             Dernier_id = case xmerl_xpath:string("dernierMessageId", Action) of % l'id du dernier message que connait le client
 130                [#xmlElement{content = [#xmlText{value = D}]}] -> erlang:list_to_integer(D, 36);
 131                _ -> 0
 132             end,
 133             User = case xmerl_xpath:string("cookie", Action) of
 134                [#xmlElement{content = [#xmlText{value = Cookie}]}] ->
 135                   case euphorik_minichat:user_by_cookie(Cookie) of
 136                      {ok, U} -> U;
 137                      _ -> inconnu
 138                   end;
 139                _ -> inconnu
 140             end,
 141             % accrochez-vous ca va siouxer ;)
 142             [{reponse, [{name, "refreshMessages"}],
 143                lists:map(
 144                   fun({Conv, Plus}) ->
 145                      {conversation, [],
 146                         [{autresPages, [], [atom_to_list(Plus)]} |
 147                            lists:map(
 148                               fun({Mess, Repond_a}) ->
 149                                  Est_proprietaire = User =/= inconnu andalso User#user.id =:= Mess#minichat.auteur_id,
 150                                  A_repondu_a_message = User =/= inconnu andalso euphorik_minichat:a_repondu_a_message(User#user.id, Mess#minichat.id),
 151                                  Est_une_reponse_a_user = User =/= inconnu andalso euphorik_minichat:est_une_reponse_a_user(User#user.id, Mess#minichat.id),
 152                                  User_mess =
 153                                     if Mess#minichat.auteur_id =:= 0 ->
 154                                           inconnu;
 155                                        true ->
 156                                           {ok, U2} = euphorik_minichat:user_by_id(Mess#minichat.auteur_id),
 157                                           U2
 158                                     end,
 159                                  {message, [{id, erlang:integer_to_list(Mess#minichat.id, 36)}],
 160                                     [
 161                                        {date, [], [format_date(Mess#minichat.date)]},
 162                                        {systeme, [], [atom_to_list(Mess#minichat.auteur_id =:= 0)]},
 163                                        {proprietaire, [], [atom_to_list(Est_proprietaire)]},
 164                                        {repondu, [], [atom_to_list(A_repondu_a_message)]},
 165                                        {reponse, [], [atom_to_list(Est_une_reponse_a_user)]},
 166                                        {pseudo, [], [Mess#minichat.pseudo]},
 167                                        {login, [], [if User_mess =:= inconnu -> Mess#minichat.pseudo; true -> User_mess#user.login end]},
 168                                        {contenu, [], [Mess#minichat.contenu]},
 169                                        {repondA, [], xml_repond_a(Repond_a)}
 170                                     ]
 171                                  }
 172                               end,
 173                               Conv
 174                            )
 175                         ]
 176                      }
 177                   end,
 178                   euphorik_minichat_conversation:conversations(
 179                      if User =/= inconnu -> User#user.conversations; true -> [] end,
 180                      Nb_message,
 181                      Dernier_id,
 182                      if User =/= inconnu -> User#user.page_principale; true -> 1 end
 183                   )
 184                )
 185             }];
 186          _ ->
 187             [{reponse, [{name, "refreshMessages"}], [{erreur, [], ["erreur"]}]}]
 188       end
 189    ).
 190
 191
 192 % Prend une liste de xml text node et en resort un string()
 193 % xmerl : "test &amp; test" devient deux fragments de texte : "test " et "& test", il faut donc rassembler les morceaux...
 194 defragmenter(Text_nodes) ->
 195    lists:foldl(fun(Node, Acc) -> #xmlText{value = V} = Node, Acc ++ V end, [], Text_nodes).
 196
 197
 198 % Un utilisateur envoie un message
 199 message(Action) ->
 200    simple_xml_to_string(
 201       case {
 202             xmerl_xpath:string("cookie", Action),
 203             xmerl_xpath:string("pseudo", Action),
 204             xmerl_xpath:string("contenu", Action)
 205          } of
 206          {
 207             [#xmlElement{content = [#xmlText{value = Cookie}]}],
 208             [#xmlElement{content = Pseudo_fragments}],
 209             [#xmlElement{content = Contenu_fragments}]
 210          } ->
 211             case euphorik_minichat:user_by_cookie(Cookie) of
 212                {ok, U} ->
 213                   Pseudo = defragmenter(Pseudo_fragments),
 214                   Contenu = defragmenter(Contenu_fragments),
 215                   % met à jour le pseudo du user
 216                   euphorik_minichat:update_pseudo_user(U#user.id, Pseudo),
 217                   Reponses = case xmerl_xpath:string("reponses", Action) of
 218                      [#xmlElement{content = C}] ->
 219                         lists:map(
 220                            fun (Reponse) ->
 221                               #xmlElement{attributes = [#xmlAttribute{name = id, value = Id_reponse}]} = Reponse,
 222                               erlang:list_to_integer(Id_reponse, 36)
 223                            end
 224                         , C);
 225                      _ -> []
 226                   end,
 227                   Contenu_strip = string:strip(Contenu),
 228                   if Contenu_strip =:= [] -> xml_reponse_message(pas_ok);
 229                      true ->
 230                         case euphorik_minichat:nouveau_message(Contenu, U#user.id, Reponses) of
 231                            erreur -> xml_reponse_message(pas_ok);
 232                         _ -> xml_reponse_message(ok)
 233                         end
 234                   end;
 235                _ -> xml_reponse_message(pas_ok)
 236             end;
 237          _ ->
 238             xml_reponse_message(pas_ok)
 239       end
 240    ).
 241
 242
 243 % Construit une erreur
 244 erreur(Message) ->
 245    {
 246       struct, [
 247          {reply, "error"},
 248          {error_message, Message}
 249       ]
 250    }.
 251
 252
 253 % Formatage d'une heure
 254 % local_time() -> string
 255 format_date(Date) ->
 256    DateLocal = calendar:now_to_local_time(Date),
 257    DateNowLocal = calendar:local_time(),
 258    {{Annee, Mois, Jour}, {Heure, Minute, Seconde}} = DateLocal,
 259    {{AnneeNow, _, _}, {_, _, _}} = DateNowLocal,
 260    Hier = calendar:date_to_gregorian_days(element(1, DateLocal)) =:=  calendar:date_to_gregorian_days(element(1, DateNowLocal)) - 1,
 261    if element(1, DateLocal) =:= element(1, DateNowLocal) ->
 262       "";
 263       Hier ->
 264          "Hier ";
 265       Annee =:= AnneeNow ->
 266          io_lib:format("~2.10.0B/~2.10.0B ", [Jour, Mois]);
 267       true ->
 268          io_lib:format("~2.10.0B/~2.10.0B/~B ", [Jour, Mois, Annee])
 269    end ++
 270    io_lib:format("~2.10.0B:~2.10.0B:~2.10.0B", [Heure, Minute, Seconde]).
 271
 272
 273 %%%%%%%%% <Réponses JSON> %%%%%%%%%
 274
 275 json_reponse_ok() ->
 276    {struct, [{status, "ok"}]}.
 277
 278
 279 % Construit une réponse positive à un login
 280 % si Enregistre vaut true alors cela veut dire que la personne s'est enregistré (elle possède au moins un login et un password)
 281 xml_reponse_login_ok(User) ->
 282    [{reponse, [{name, "login"}],
 283       [
 284          {statut, [if (User#user.password =/= []) and (User#user.login =/= []) -> "enregistre"; true -> "identifie" end]},
 285          {cookie, [User#user.cookie]},
 286          {id, [erlang:integer_to_list(User#user.id, 36)]},
 287          {pseudo, [User#user.pseudo]},
 288          {login, [User#user.login]},
 289          {email, [User#user.email]},
 290          {css, [User#user.css]},
 291          {pagePrincipale, [integer_to_list(User#user.page_principale)]}
 292       ] ++
 293       lists:map(
 294          fun(C) ->
 295             {conversation,
 296                [
 297                   {racine, [erlang:integer_to_list(element(1, C), 36)]},
 298                   {page, [integer_to_list(element(2, C))]}
 299                ]
 300             }
 301          end,
 302          User#user.conversations
 303       )
 304    }].
 305
 306
 307 json_reponse_login_ok(User) ->
 308    {
 309       struct, [
 310          {reply, "login"},
 311          {status, if (User#user.password =/= []) and (User#user.login =/= []) -> "enregistre"; true -> "identifie" end},
 312          {cookie, User#user.cookie},
 313          {id, User#user.id},
 314          {pseudo, User#user.pseudo},
 315          {login, User#user.login},
 316          {email, User#user.email},
 317          {css, User#user.css},
 318          {main_page, User#user.page_principale},
 319          {conversations,
 320             {array,
 321                lists:map(
 322                   fun(C) ->
 323                      {struct,
 324                         {root, element(1, C)},
 325                         {page, element(2, C)}
 326                      }
 327                   end,
 328                   User#user.conversations
 329                )
 330             }
 331          }
 332       ]
 333    }.
 334
 335
 336 % Construit un réponse négative à un login
 337 xml_reponse_login_pas_ok(Message) ->
 338    [{reponse, [{name, "login"}],
 339       [
 340          {statut, ["erreur"]},
 341          {information, [Message]}
 342       ]
 343    }].
 344
 345
 346 % Pas utilisé
 347 %~ xml_conversation(Mess_id, Nb) ->
 348    %~ {Mess_id, Conversation} = minichat:conversation(Mess_id, Nb),
 349    %~ xml_conversation(Conversation).
 350 %~ xml_conversation([]) -> [];
 351 %~ xml_conversation(Liste_id) ->
 352    %~ lists:map(
 353       %~ fun({Id, Sous_liste}) ->
 354          %~ {id, [{id, erlang:integer_to_list(Id, 36)}], xml_conversation(Sous_liste)}
 355       %~ end,
 356       %~ Liste_id
 357    %~ ).
 358
 359
 360 % Renvoie un element XML representant une liste de messages auquel le message M_id repond
 361 xml_repond_a(Reponses) ->
 362    lists:map(
 363       fun(Id_mess) ->
 364          {ok, M} = euphorik_minichat:message_by_id(Id_mess),
 365          {ok, User} = euphorik_minichat:user_by_mess(Id_mess),
 366          {id, [{id, erlang:integer_to_list(M#minichat.id, 36)}, {pseudo, M#minichat.pseudo}, {login, User#user.login}], []}
 367       end,
 368       Reponses
 369    ).
 370
 371
 372 xml_reponse_message(Ok) ->
 373    [
 374       {reponse, [{name, "message"}],
 375          [
 376             {statut, [], [case Ok of ok -> "ok"; pas_ok -> "pas ok" end]}
 377          ]
 378       }
 379    ].
 380
 381 %%%%%%%%% </réponses XML> %%%%%%%%%