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 = case euphorik_minichat:user_by_cookie(Cookie) of
 119       {ok U} -> U;
 120       _ -> inconnu
 121    end,
 122    {stuct, [
 123       {reply, "new_message"},
 124       {conversations, {array,
 125          TODO ...
 126       }
 127    ]}
 128
 129             % accrochez-vous ca va siouxer ;)
 130             [{reponse, [{name, "refreshMessages"}],
 131                lists:map(
 132                   fun({Conv, Plus}) ->
 133                      {conversation, [],
 134                         [{autresPages, [], [atom_to_list(Plus)]} |
 135                            lists:map(
 136                               fun({Mess, Repond_a}) ->
 137                                  Est_proprietaire = User =/= inconnu andalso User#user.id =:= Mess#minichat.auteur_id,
 138                                  A_repondu_a_message = User =/= inconnu andalso euphorik_minichat:a_repondu_a_message(User#user.id, Mess#minichat.id),
 139                                  Est_une_reponse_a_user = User =/= inconnu andalso euphorik_minichat:est_une_reponse_a_user(User#user.id, Mess#minichat.id),
 140                                  User_mess =
 141                                     if Mess#minichat.auteur_id =:= 0 ->
 142                                           inconnu;
 143                                        true ->
 144                                           {ok, U2} = euphorik_minichat:user_by_id(Mess#minichat.auteur_id),
 145                                           U2
 146                                     end,
 147                                  {message, [{id, erlang:integer_to_list(Mess#minichat.id, 36)}],
 148                                     [
 149                                        {date, [], [format_date(Mess#minichat.date)]},
 150                                        {systeme, [], [atom_to_list(Mess#minichat.auteur_id =:= 0)]},
 151                                        {proprietaire, [], [atom_to_list(Est_proprietaire)]},
 152                                        {repondu, [], [atom_to_list(A_repondu_a_message)]},
 153                                        {reponse, [], [atom_to_list(Est_une_reponse_a_user)]},
 154                                        {pseudo, [], [Mess#minichat.pseudo]},
 155                                        {login, [], [if User_mess =:= inconnu -> Mess#minichat.pseudo; true -> User_mess#user.login end]},
 156                                        {contenu, [], [Mess#minichat.contenu]},
 157                                        {repondA, [], xml_repond_a(Repond_a)}
 158                                     ]
 159                                  }
 160                               end,
 161                               Conv
 162                            )
 163                         ]
 164                      }
 165                   end,
 166                   euphorik_minichat_conversation:conversations(
 167                      if User =/= inconnu -> User#user.conversations; true -> [] end,
 168                      Nb_message,
 169                      Dernier_id,
 170                      if User =/= inconnu -> User#user.page_principale; true -> 1 end
 171                   )
 172                )
 173             }];
 174          _ ->
 175             [{reponse, [{name, "refreshMessages"}], [{erreur, [], ["erreur"]}]}]
 176       end
 177    ).
 178
 179
 180 % Prend une liste de xml text node et en resort un string()
 181 % xmerl : "test &amp; test" devient deux fragments de texte : "test " et "& test", il faut donc rassembler les morceaux...
 182 defragmenter(Text_nodes) ->
 183    lists:foldl(fun(Node, Acc) -> #xmlText{value = V} = Node, Acc ++ V end, [], Text_nodes).
 184
 185
 186 % Un utilisateur envoie un message
 187 message(Action) ->
 188    simple_xml_to_string(
 189       case {
 190             xmerl_xpath:string("cookie", Action),
 191             xmerl_xpath:string("pseudo", Action),
 192             xmerl_xpath:string("contenu", Action)
 193          } of
 194          {
 195             [#xmlElement{content = [#xmlText{value = Cookie}]}],
 196             [#xmlElement{content = Pseudo_fragments}],
 197             [#xmlElement{content = Contenu_fragments}]
 198          } ->
 199             case euphorik_minichat:user_by_cookie(Cookie) of
 200                {ok, U} ->
 201                   Pseudo = defragmenter(Pseudo_fragments),
 202                   Contenu = defragmenter(Contenu_fragments),
 203                   % met à jour le pseudo du user
 204                   euphorik_minichat:update_pseudo_user(U#user.id, Pseudo),
 205                   Reponses = case xmerl_xpath:string("reponses", Action) of
 206                      [#xmlElement{content = C}] ->
 207                         lists:map(
 208                            fun (Reponse) ->
 209                               #xmlElement{attributes = [#xmlAttribute{name = id, value = Id_reponse}]} = Reponse,
 210                               erlang:list_to_integer(Id_reponse, 36)
 211                            end
 212                         , C);
 213                      _ -> []
 214                   end,
 215                   Contenu_strip = string:strip(Contenu),
 216                   if Contenu_strip =:= [] -> xml_reponse_message(pas_ok);
 217                      true ->
 218                         case euphorik_minichat:nouveau_message(Contenu, U#user.id, Reponses) of
 219                            erreur -> xml_reponse_message(pas_ok);
 220                         _ -> xml_reponse_message(ok)
 221                         end
 222                   end;
 223                _ -> xml_reponse_message(pas_ok)
 224             end;
 225          _ ->
 226             xml_reponse_message(pas_ok)
 227       end
 228    ).
 229
 230
 231 % Construit une erreur
 232 erreur(Message) ->
 233    {
 234       struct, [
 235          {reply, "error"},
 236          {error_message, Message}
 237       ]
 238    }.
 239
 240
 241 % Formatage d'une heure
 242 % local_time() -> string
 243 format_date(Date) ->
 244    DateLocal = calendar:now_to_local_time(Date),
 245    DateNowLocal = calendar:local_time(),
 246    {{Annee, Mois, Jour}, {Heure, Minute, Seconde}} = DateLocal,
 247    {{AnneeNow, _, _}, {_, _, _}} = DateNowLocal,
 248    Hier = calendar:date_to_gregorian_days(element(1, DateLocal)) =:=  calendar:date_to_gregorian_days(element(1, DateNowLocal)) - 1,
 249    if element(1, DateLocal) =:= element(1, DateNowLocal) ->
 250       "";
 251       Hier ->
 252          "Hier ";
 253       Annee =:= AnneeNow ->
 254          io_lib:format("~2.10.0B/~2.10.0B ", [Jour, Mois]);
 255       true ->
 256          io_lib:format("~2.10.0B/~2.10.0B/~B ", [Jour, Mois, Annee])
 257    end ++
 258    io_lib:format("~2.10.0B:~2.10.0B:~2.10.0B", [Heure, Minute, Seconde]).
 259
 260
 261 %%%%%%%%% <Réponses JSON> %%%%%%%%%
 262
 263 json_reponse_ok() ->
 264    {struct, [{reply, "ok"}]}.
 265
 266
 267 % Construit une réponse positive à un login
 268 % si Enregistre vaut true alors cela veut dire que la personne s'est enregistré (elle possède au moins un login et un password)
 269 xml_reponse_login_ok(User) ->
 270    [{reponse, [{name, "login"}],
 271       [
 272          {statut, [if (User#user.password =/= []) and (User#user.login =/= []) -> "enregistre"; true -> "identifie" end]},
 273          {cookie, [User#user.cookie]},
 274          {id, [erlang:integer_to_list(User#user.id, 36)]},
 275          {pseudo, [User#user.pseudo]},
 276          {login, [User#user.login]},
 277          {email, [User#user.email]},
 278          {css, [User#user.css]},
 279          {pagePrincipale, [integer_to_list(User#user.page_principale)]}
 280       ] ++
 281       lists:map(
 282          fun(C) ->
 283             {conversation,
 284                [
 285                   {racine, [erlang:integer_to_list(element(1, C), 36)]},
 286                   {page, [integer_to_list(element(2, C))]}
 287                ]
 288             }
 289          end,
 290          User#user.conversations
 291       )
 292    }].
 293
 294
 295 json_reponse_login_ok(User) ->
 296    {
 297       struct, [
 298          {reply, "login"},
 299          {status, if (User#user.password =/= []) and (User#user.login =/= []) -> "enregistre"; true -> "identifie" end},
 300          {cookie, User#user.cookie},
 301          {id, User#user.id},
 302          {pseudo, User#user.pseudo},
 303          {login, User#user.login},
 304          {email, User#user.email},
 305          {css, User#user.css},
 306          {main_page, User#user.page_principale},
 307          {conversations,
 308             {array,
 309                lists:map(
 310                   fun(C) ->
 311                      {struct,
 312                         {root, element(1, C)},
 313                         {page, element(2, C)}
 314                      }
 315                   end,
 316                   User#user.conversations
 317                )
 318             }
 319          }
 320       ]
 321    }.
 322
 323
 324 % Construit un réponse négative à un login
 325 xml_reponse_login_pas_ok(Message) ->
 326    [{reponse, [{name, "login"}],
 327       [
 328          {statut, ["erreur"]},
 329          {information, [Message]}
 330       ]
 331    }].
 332
 333
 334 % Pas utilisé
 335 %~ xml_conversation(Mess_id, Nb) ->
 336    %~ {Mess_id, Conversation} = minichat:conversation(Mess_id, Nb),
 337    %~ xml_conversation(Conversation).
 338 %~ xml_conversation([]) -> [];
 339 %~ xml_conversation(Liste_id) ->
 340    %~ lists:map(
 341       %~ fun({Id, Sous_liste}) ->
 342          %~ {id, [{id, erlang:integer_to_list(Id, 36)}], xml_conversation(Sous_liste)}
 343       %~ end,
 344       %~ Liste_id
 345    %~ ).
 346
 347
 348 % Renvoie un element XML representant une liste de messages auquel le message M_id repond
 349 xml_repond_a(Reponses) ->
 350    lists:map(
 351       fun(Id_mess) ->
 352          {ok, M} = euphorik_minichat:message_by_id(Id_mess),
 353          {ok, User} = euphorik_minichat:user_by_mess(Id_mess),
 354          {id, [{id, erlang:integer_to_list(M#minichat.id, 36)}, {pseudo, M#minichat.pseudo}, {login, User#user.login}], []}
 355       end,
 356       Reponses
 357    ).
 358
 359
 360 xml_reponse_message(Ok) ->
 361    [
 362       {reponse, [{name, "message"}],
 363          [
 364             {statut, [], [case Ok of ok -> "ok"; pas_ok -> "pas ok" end]}
 365          ]
 366       }
 367    ].
 368
 369 %%%%%%%%% </réponses XML> %%%%%%%%%