ADD affichage des ip bannies sur la page d'admin (pas fini, manque bouton "debannir")
[euphorik.git] / modules / erl / euphorik_bd.erl
1 % coding: utf-8
2 % Ce module permet de gérer les données persistantes lié au site d'euphorik.ch.
3 % Il permet d'ajouter des message, de demande les messages sur une page donnée, etc..
4 % Ce module utilise une base mnesia.
5 % @author G.Burri
6
7 -module(euphorik_bd).
8 -export([
9 % gestion :
10 create/0,
11 connect/0,
12 connect/1,
13 reset/0,
14
15 % users :
16 nouveau_user/2,
17 nouveau_user/3,
18 set_profile/9,
19 update_date_derniere_connexion/1,
20 update_ip/2,
21 update_pseudo_user/2,
22 print_users/0,
23 print_users/1,
24 print_user/1,
25 user_by_cookie/1,
26 user_by_id/1,
27 user_by_login/1,
28 user_by_login_password/2,
29 user_by_mess/1,
30 toggle_ek_master/1,
31
32 % messages :
33 nouveau_message/3,
34 nouveau_message_sys/1,
35 messages/1,
36 messages/2,
37 messages/3,
38 message_by_id/1,
39 messages_by_ids/1,
40 message_existe/1,
41 reponses/0,
42 repond_a/1,
43 est_une_reponse_a_user/2,
44 a_repondu_a_message/2,
45 possede_message/2,
46
47 % ip :
48 list_ban/0,
49 ban/2,
50 deban/1,
51 est_banni/1,
52 can_register/1,
53
54 % trolls :
55 trolls/0,
56 trolls/1,
57 trolls_attente/1,
58 put_troll/2,
59 mod_troll/2,
60 del_troll/1,
61 troll_by_id/1,
62 current_troll/0,
63 elire_troll/0,
64
65 % versions :
66 update_version/1,
67
68 % utiles :
69 resultat_transaction/1
70 ]).
71 -import(qlc, [e/1, e/2, q/1, cursor/1]).
72 -include("../include/euphorik_bd.hrl").
73 -include("../include/euphorik_defines.hrl").
74 -include_lib("stdlib/include/qlc.hrl").
75
76
77 % Instructions pour créer une nouvelle base :
78 % $erl -sname yaws -mnesia dir '"/projets/euphorik/BD"'
79 % voir doc/installation.txt
80 % >l(euphorik_bd).
81 % >euphorik_bd:create().
82 create() ->
83 mnesia:stop(),
84 mnesia:delete_schema([node()]),
85 mnesia:create_schema([node()]), % nécessaire pour les tables sur disc
86 mnesia:start(),
87 create_tables(),
88 reset().
89 create_tables() ->
90 mnesia:create_table(counter, [
91 {attributes, record_info(fields, counter)},
92 {disc_copies, [node()]}
93 ]),
94 mnesia:create_table(minichat, [
95 {attributes, record_info(fields, minichat)},
96 {index, [auteur_id]},
97 {disc_copies, [node()]}
98 ]),
99 mnesia:create_table(reponse_minichat, [
100 {type, bag},
101 {attributes, record_info(fields, reponse_minichat)},
102 {index, [cible]},
103 {disc_copies, [node()]}
104 ]),
105 mnesia:create_table(user, [
106 {attributes, record_info(fields, user)},
107 {index, [cookie, login]},
108 {disc_copies, [node()]}
109 ]),
110 mnesia:create_table(ip_table, [
111 {attributes, record_info(fields, ip_table)},
112 {disc_copies, [node()]}
113 ]),
114 mnesia:create_table(troll, [
115 {attributes, record_info(fields, troll)},
116 {index, [date_post]},
117 {disc_copies, [node()]}
118 ]).
119
120
121 % Connexion à la base de données de yaws sur overnux
122 connect() ->
123 connect(yaws@flynux).
124 connect(Node) ->
125 mnesia:start(),
126 mnesia:change_config(extra_db_nodes, [Node]).
127
128
129 % Efface tous les users, minichat_reponse et minichat.
130 reset() ->
131 mnesia:clear_table(counter),
132 mnesia:clear_table(user),
133 mnesia:clear_table(reponse_minichat),
134 mnesia:clear_table(minichat),
135 mnesia:clear_table(troll),
136 mnesia:clear_table(ip_table),
137 % crée l'utilisateur root
138 mnesia:transaction(fun() ->
139 User = #user{id = 0, pseudo = "Sys", login = "Sys", date_creation = now(), date_derniere_connexion = now(), ek_master = true},
140 mnesia:write(User),
141 User
142 end).
143
144
145 % Ajoute un nouveau user et le renvoie
146 nouveau_user(Pseudo, Cookie) ->
147 F = fun() ->
148 Id = nouvel_id(user),
149 User = #user{id = Id, cookie = Cookie, pseudo = Pseudo, date_creation = now(), date_derniere_connexion = now()},
150 mnesia:write(User),
151 User
152 end,
153 resultat_transaction(mnesia:transaction(F)).
154
155
156 % Ajoute un nouveau user et le renvoie
157 nouveau_user(Login, Password, Cookie) ->
158 F = fun() ->
159 Id = nouvel_id(user),
160 User = #user{id = Id, cookie = Cookie, pseudo = Login, login = Login, password = Password, date_creation = now(), date_derniere_connexion = now()},
161 mnesia:write(User),
162 User
163 end,
164 resultat_transaction(mnesia:transaction(F)).
165
166
167 % Mise à par Cookie les autres peuvent être undefined ce qui veut dire qu'ils ne seront pas modifié.
168 set_profile(Cookie, Login, Password, Pseudo, Email, Css, Nick_format, Page_principale, Conversations) ->
169 if Nick_format =:= nick; Nick_format =:= login; Nick_format =:= nick_login ->
170 resultat_transaction(mnesia:transaction(
171 fun() ->
172 case user_by_cookie(Cookie) of
173 {ok, User} ->
174 case user_by_login(Login) of
175 {ok, U} when Login =/= [], U#user.id =/= User#user.id ->
176 login_deja_pris;
177 _ ->
178 User_modifie = User#user{
179 % TODO : pourquoi ne pas tester avec la valeur "undefined" plutôt qu'avec "is_list" ?
180 % TODO : validation plus strict des données (pas de page négative dans les conv par exemple)
181 login = if is_list(Login) -> Login; true -> User#user.login end,
182 password = if is_list(Password) andalso Password =/= [] -> Password; true -> User#user.password end,
183 pseudo = if is_list(Pseudo) -> Pseudo; true -> User#user.pseudo end,
184 email = if is_list(Email) -> Email; true -> User#user.email end,
185 css = if is_list(Css) -> Css; true -> User#user.css end,
186 nick_format = Nick_format,
187 page_principale = if is_integer(Page_principale), Page_principale > 0 -> Page_principale; true -> User#user.page_principale end,
188 conversations = if is_list(Conversations) -> Conversations; true -> User#user.conversations end
189 },
190 mnesia:write(User_modifie),
191 ok
192 end;
193 _ -> erreur
194 end
195 end
196 ));
197 true ->
198 erreur
199 end.
200
201
202 % Met à jour la date de la dernière connexion d'un utilisateur à maintenant
203 update_date_derniere_connexion(User_id) ->
204 mnesia:transaction(
205 fun() ->
206 case mnesia:wread({user, User_id}) of
207 [User] ->
208 mnesia:write(User#user{date_derniere_connexion = now()});
209 _ ->
210 mnesia:abort("update_date_derniere_connexion: User inconnu")
211 end
212 end
213 ).
214
215
216 % Met à jour l'ip d'un user
217 update_ip(User_id, IP) ->
218 mnesia:transaction(
219 fun() ->
220 case mnesia:wread({user, User_id}) of
221 [User] ->
222 mnesia:write(User#user{last_ip = IP});
223 _ ->
224 mnesia:abort("update_ip: User inconnu")
225 end
226 end
227 ).
228
229
230 % Met à jour le pseudo du user
231 update_pseudo_user(UserId, Pseudo) ->
232 mnesia:transaction(
233 fun() ->
234 case mnesia:wread({user, UserId}) of
235 [User] when User#user.pseudo =/= Pseudo ->
236 mnesia:write(User#user{pseudo = Pseudo});
237 _ ->
238 mnesia:abort("update_pseudo_user: User inconnu ou pseudo deja à jour")
239 end
240 end
241 ).
242
243
244 % Affiche N user trié par leur date de dernière connexion.
245 % Attention : pas d'index sur ce champs (la date)
246 print_users(N) ->
247 resultat_transaction(mnesia:transaction(fun() ->
248 C = cursor(q([E || E <- qlc:keysort(9, mnesia:table(user), [{order, descending}])])),
249 Users = qlc:next_answers(C, N),
250 lists:foreach(
251 fun(U) ->
252 print_user(U)
253 end,
254 Users
255 ),
256 qlc:delete_cursor(C)
257 end)).
258
259
260 % Affiche tous les users.
261 print_users() ->
262 print_users(all_remaining).
263
264
265 print_user(User) when is_record(User, user) ->
266 #user{id = Id, pseudo = Pseudo, login = Login, ek_master = Ek_master, date_derniere_connexion = Date} = User,
267 {{Annee, Mois, Jour}, {Heure, Min, _}} = calendar:now_to_local_time(Date),
268 io:format(
269 "~4w : ~10.10..s~10.10..s ~2w.~2.2.0w.~w - ~2wh~2.2.0w~n",
270 [
271 Id,
272 if Ek_master -> "*"; true -> "" end ++ Pseudo,
273 "(" ++ Login ++ ")",
274 Jour, Mois, Annee, Heure, Min
275 ]
276 );
277 % Affichage d'un user en fonction de son login
278 print_user(Login) when is_list(Login) ->
279 case user_by_login(Login) of
280 {ok, User} ->
281 print_user(User);
282 _ ->
283 {erreur, "Login pas trouvé : " ++ Login}
284 end;
285 % Affichage d'un user en fonction de son id
286 print_user(Id) when is_integer(Id) ->
287 case user_by_id(Id) of
288 {ok, User} ->
289 print_user(User);
290 _ ->
291 {erreur, "Id pas trouvé : " ++ integer_to_list(Id)}
292 end.
293
294
295 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
296 % Renvoie {ok, User} ou erreur
297 user_by_cookie(Cookie) ->
298 resultat_transaction(mnesia:transaction(
299 fun() ->
300 case e(q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie])) of
301 [User] -> {ok, User};
302 _ -> erreur
303 end
304 end
305 )).
306
307
308 user_by_id(ID) ->
309 resultat_transaction(mnesia:transaction(
310 fun() ->
311 case e(q([E || E <- mnesia:table(user), E#user.id =:= ID])) of
312 [User] -> {ok, User};
313 _ -> erreur
314 end
315 end
316 )).
317
318
319 user_by_login(Login) ->
320 resultat_transaction(mnesia:transaction(
321 fun() ->
322 Users = e(q([E || E <- mnesia:table(user), E#user.login =:= Login])),
323 case Users of
324 [User] -> {ok, User};
325 _ -> erreur
326 end
327 end
328 )).
329
330
331 toggle_ek_master(User_id) ->
332 resultat_transaction(mnesia:transaction(
333 fun() ->
334 Users = e(q([E || E <- mnesia:table(user), E#user.id =:= User_id])),
335 case Users of
336 [User] ->
337 mnesia:write(User#user{ek_master = not User#user.ek_master});
338 _ -> erreur
339 end
340 end
341 )).
342
343
344 user_by_login_password(Login, Password) ->
345 resultat_transaction(mnesia:transaction(
346 fun() ->
347 case e(q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password])) of
348 [User | _] -> {ok, User};
349 _ -> erreur
350 end
351 end
352 )).
353
354
355 % Renvoie {ok, User} où User est un #user possédant le message donné.
356 user_by_mess(Id) ->
357 resultat_transaction(mnesia:transaction(
358 fun() ->
359 case e(q([U || U <- mnesia:table(user), M <- mnesia:table(minichat), M#minichat.id =:= Id, M#minichat.auteur_id =:= U#user.id])) of
360 [User | _] -> {ok, User};
361 _ -> erreur
362 end
363 end
364 )).
365
366
367 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
368 % retourne soit l'id du message soit {erreur, <raison>}.
369 nouveau_message(Mess, Auteur_id, Repond_A) ->
370 % regarde si les id 'Repond_A' existent
371 F = fun() ->
372 Nb_id_trouve = length(e(q([E#minichat.id || E <- mnesia:table(minichat), lists:member(E#minichat.id, Repond_A)]))),
373 % est-ce que l'auteur existe ?
374 Auteur = case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id])) of
375 [A] -> A;
376 _ -> {erreur, "L'auteur du message est introuvable"}
377 end,
378 if Nb_id_trouve =/= length(Repond_A) ->
379 {erreur, "Un ou plusieurs messages introuvable"};
380 true ->
381 % comparaison entre la date du dernier poste et maintenant (gestion du flood)
382 Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
383 Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
384 Auteur_maj = Auteur#user{
385 indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
386 date_derniere_connexion = now()
387 },
388 % est-ce que l'auteur à trop floodé ?
389 if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
390 mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
391 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.");
392 Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
393 {erreur, "Bloqué pour cause de flood"};
394 true ->
395 mnesia:write(Auteur_maj),
396 Id = nouvel_id(minichat),
397 inserer_reponses(Id, Repond_A),
398 mnesia:write(#minichat{id=Id, auteur_id=Auteur#user.id, date=now(), pseudo=Auteur#user.pseudo, contenu=Mess}),
399 Id
400 end
401 end
402 end,
403 resultat_transaction(mnesia:transaction(F)).
404
405 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
406 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
407 mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
408 inserer_reponses(Id_repondant, Reste);
409 inserer_reponses(_, []) ->
410 ok.
411
412
413 % Permet de créer un message système.
414 % Renvoie l'id du message système
415 nouveau_message_sys(Mess) ->
416 {ok, Root} = user_by_id(0),
417 mnesia:transaction(
418 fun() ->
419 Id = nouvel_id(minichat),
420 mnesia:write(#minichat{id=Id, auteur_id=0, date=now(), pseudo=Root#user.pseudo, contenu=Mess})
421 end
422 ).
423
424
425 % Renvoie N messages se trouvant sur la première page
426 messages(N) ->
427 messages(N, 1).
428
429
430 % Renvoie N messages se trouvant sur la page P
431 messages(N, P) ->
432 F = fun() ->
433 C = cursor(q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, descending}])])),
434 if P > 1 -> qlc:next_answers(C, N * (P - 1));
435 true -> ok
436 end,
437 R = qlc:next_answers(C, N),
438 qlc:delete_cursor(C),
439 lists:reverse(R)
440 end,
441 resultat_transaction(mnesia:transaction(F)).
442
443
444 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
445 % par page et que le dernier message que l'on possède est Id
446 messages(Id, N, P) ->
447 lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
448
449
450 % Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
451 message_by_id(Id) ->
452 case resultat_transaction(mnesia:transaction(
453 fun() ->
454 e(q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), Id =:= E#minichat.id]))
455 end
456 )) of
457 [M] -> {ok, M};
458 _ -> erreur
459 end.
460
461
462 % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
463 messages_by_ids(Ids) ->
464 resultat_transaction(mnesia:transaction(
465 fun() ->
466 % TODO : optimisations ? serait-ce du O(n) ?
467 Query = q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
468 e(Query)
469 end
470 )).
471
472
473 % Est-ce qu'un message existe ? Renvoie un boolean.
474 % TODO : ya pas plus simple ?
475 message_existe(Id) ->
476 resultat_transaction(mnesia:transaction(fun() ->
477 length(e(q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]))) =:= 1
478 end)).
479
480
481 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
482 reponses() ->
483 F = fun() ->
484 e(q([E || E <- mnesia:table(reponse_minichat)]))
485 end,
486 resultat_transaction(mnesia:transaction(F)).
487
488
489 % Renvoie les messages auquel M_id répond.
490 repond_a(M_id) ->
491 resultat_transaction(mnesia:transaction(
492 fun() ->
493 e(q(
494 [M || E <- mnesia:table(reponse_minichat),
495 M <- mnesia:table(minichat),
496 E#reponse_minichat.repondant =:= M_id,
497 M#minichat.id =:= E#reponse_minichat.cible]))
498 end
499 )).
500
501
502 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
503 est_une_reponse_a_user(Id_user, Id_mess) ->
504 case mnesia:transaction(
505 fun() ->
506 e(q([
507 M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
508 M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
509 ]), [{unique_all, true}])
510 end
511 ) of
512 {atomic, [_]} -> true;
513 _ -> false
514 end.
515
516
517 % Est-ce que Id_user à répondu au message Id_mess
518 a_repondu_a_message(Id_user, Id_mess) ->
519 case mnesia:transaction(
520 fun() ->
521 e(q([
522 M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
523 R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
524 ]), [{unique_all, true}])
525 end
526 ) of
527 {atomic, [_]} -> true;
528 _ -> false
529 end.
530
531
532 % Est-ce que Id_user possède Id_mess ?
533 possede_message(Id_user, Id_mess) ->
534 case mnesia:transaction(
535 fun() ->
536 e(q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]))
537 end
538 ) of
539 {atomic, [Id_user | []]} -> true;
540 _ -> false
541 end.
542
543
544 % renvoie la liste des ip bannies
545 % liste de {ip, temps_restant(en minutes), Users} ou Users est une liste de {pseudo, login}
546 % TODO : déterminer la complexité de cette fonction. (Il n'y a pas d'index sur #user.last_ip)
547 list_ban() ->
548 resultat_transaction(mnesia:transaction(
549 fun() ->
550 Now = now(),
551 e(q([
552 {
553 IP#ip_table.ip,
554 delta_date_minute(date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration), Now),
555 e(q([{U#user.pseudo, U#user.login} || U <- mnesia:table(user), U#user.last_ip =:= IP#ip_table.ip]))
556 } ||
557 IP <- qlc:keysort(2, mnesia:table(ip_table)),
558 date_plus_minutes(IP#ip_table.ban, IP#ip_table.ban_duration) > Now
559 ]))
560 end
561 )).
562
563
564 % Bannie une ip pour un certain temps (en minute).
565 ban(IP, Duration) ->
566 mnesia:transaction(
567 fun() ->
568 case mnesia:wread({ip_table, IP}) of
569 [IP_tuple] ->
570 mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
571 _ ->
572 mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
573 end
574 end
575 ).
576
577
578 % Débanni une ip
579 deban(IP) ->
580 ban(IP, 0).
581
582
583 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
584 % ou false.
585 est_banni(User_id) ->
586 resultat_transaction(mnesia:transaction(
587 fun() ->
588 case e(q([
589 {IP#ip_table.ban, IP#ip_table.ban_duration} ||
590 U <- mnesia:table(user),
591 U#user.id =:= User_id,
592 IP <- mnesia:table(ip_table),
593 IP#ip_table.ip =:= U#user.last_ip
594 ])) of
595 [{Ban, Ban_duration}] ->
596 Echeance = date_plus_minutes(Ban, Ban_duration),
597 Now = now(),
598 if Echeance < Now -> % l'échéance est passée
599 false;
600 true ->
601 {true, delta_date_minute(Echeance, Now)}
602 end;
603 _ ->
604 false
605 end
606 end
607 )).
608
609
610 % Ban est une date tel que retourner par now().
611 % Ban_duration est un temps en minutes.
612 % retourne une date.
613 date_plus_minutes(Ban, Ban_duration) ->
614 Duration_sec = Ban_duration * 60,
615 {MegaSec, Sec, MicroSec} = Ban,
616 {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
617
618
619 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
620 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
621 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
622 can_register(IP) ->
623 resultat_transaction(mnesia:transaction(
624 fun() ->
625 case e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP])) of
626 [] ->
627 mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
628 true;
629 [T] ->
630 Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
631 if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
632 false;
633 true ->
634 mnesia:write(#ip_table{
635 ip = IP,
636 date_last_try_register = now(),
637 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
638 }),
639 true
640 end
641 end
642 end
643 )).
644
645
646 % Renvoie tous les trolls
647 trolls() ->
648 resultat_transaction(mnesia:transaction(
649 fun() ->
650 e(q([T || T <- qlc:keysort(2, mnesia:table(troll))]))
651 end
652 )).
653
654
655 % Renvoie les trolls manquants posté après Last_id.
656 trolls(Last_id) ->
657 resultat_transaction(mnesia:transaction(
658 e(q([T || T <- qlc:keysort(2, mnesia:table(troll)), T#troll.id > Last_id, T#troll.date_post =:= undefined]))
659 )).
660
661
662 % Renvoie les trolls manquants posté après Last_id.
663 % Si pas de trolls alors attend un événement tel qu'un ajout, une modification ou une suppression.
664 % renvoie :
665 % {mod, Troll}
666 % ou {add, [Trolls]}
667 % ou {del, Troll_id}
668 % ou timeout
669 trolls_attente(Last_id) ->
670 case mnesia:subscribe({table, troll, detailed}) of
671 {error, E} = E ->
672 E;
673 _ ->
674 R = case resultat_transaction(mnesia:transaction(
675 fun() ->
676 e(q([T || T <- qlc:keysort(2, mnesia:table(troll)), T#troll.id > Last_id, T#troll.date_post =:= undefined]))
677 end
678 )) of
679 [] -> % pas de trolls
680 attend_evenement_troll();
681 Trolls ->
682 {add, Trolls}
683 end,
684 mnesia:unsubscribe({table, troll, detailed}),
685 R
686 end.
687
688 attend_evenement_troll() ->
689 % s'il n'y a pas de trolls que l'utilisateur n'a pas connaissance alors on attend un événement
690 receive
691 % cas où un troll est choisit comme courant
692 {mnesia_table_event, {write, troll, Troll, [Old_troll | _], _}} when Old_troll#troll.date_post =:= undefined, Troll#troll.date_post =/= undefined ->
693 {del, Troll#troll.id};
694 {mnesia_table_event, {write, troll, Troll, [_Old_troll | _], _}} ->
695 {mod, Troll};
696 {mnesia_table_event, {write, troll, Troll, [], _}} ->
697 {add, [Troll]};
698 {mnesia_table_event, {delete, troll, {troll, Id}, _, _}} ->
699 {del, Id};
700 {tcp_closed, _} ->
701 exit(normal);
702 _ ->
703 attend_evenement_troll()
704 % 60 minutes de timeout (on ne sais jamais)
705 % Après 60 minutes de connexion, le client doit donc reétablir une connexion
706 after 1000 * 60 * 60 ->
707 timeout
708 end.
709
710
711 % Renvoie l'id du nouveau troll
712 % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind
713 % ou max_troll_reached si le nombre de troll posté max a été atteind
714 % ou user_unknown
715 put_troll(User_id, Content) ->
716 resultat_transaction(mnesia:transaction(
717 fun() ->
718 % control le nombre de troll déjà posté
719 Nb_troll_poste_par_user = length(e(q(
720 [
721 E#troll.id || E <- mnesia:table(troll),
722 E#troll.id_user =:= User_id,
723 E#troll.date_post =:= undefined
724 ]
725 ))),
726 Nb_troll_poste_total = length(e(q(
727 [
728 E#troll.id || E <- mnesia:table(troll),
729 E#troll.date_post =:= undefined
730 ]
731 ))),
732 User = user_by_id(User_id),
733 case User of
734 {ok, _} ->
735 if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER ->
736 max_troll_reached_per_user;
737 Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING ->
738 max_troll_reached;
739 true ->
740 Id = nouvel_id(minichat),
741 mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}),
742 Id
743 end;
744 _ ->
745 user_unknown
746 end
747 end
748 )).
749
750
751 % renvoie ok | erreur
752 mod_troll(Troll_id, Content) ->
753 mnesia:transaction(
754 fun() ->
755 case mnesia:wread({troll, Troll_id}) of
756 [Troll = #troll{date_post = undefined}] ->
757 mnesia:write(Troll#troll{content = Content});
758 _ ->
759 mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
760 end
761 end
762 ).
763
764
765 del_troll(Troll_id) ->
766 mnesia:transaction(
767 fun() ->
768 case mnesia:wread({troll, Troll_id}) of
769 [#troll{date_post = undefined}] ->
770 mnesia:delete({troll, Troll_id});
771 _ ->
772 mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
773 end
774 end
775 ).
776
777
778 troll_by_id(Troll_id) ->
779 resultat_transaction(mnesia:transaction(
780 fun() ->
781 case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id])) of
782 [T] -> {ok, T};
783 _ ->
784 erreur
785 end
786 end
787 )).
788
789
790 % Renvoie le troll actuel qui se trouve sur la page principale.
791 % Renvois aucun si pas de troll courant.
792 current_troll() ->
793 resultat_transaction(mnesia:transaction(
794 fun() ->
795 % TODO : ya pas moyen de désigner le champs plutot qu'avec un nombre pour le tri ?
796 C = cursor(q([T || T <- qlc:keysort(5, mnesia:table(troll), [{order, descending}]), T#troll.date_post =/= undefined])),
797 R = case qlc:next_answers(C, 1) of
798 [T] -> T;
799 _ -> aucun
800 end,
801 qlc:delete_cursor(C),
802 R
803 end
804 )).
805
806
807 % Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined)
808 % met à jour sa date de post.
809 % renvoie plus_de_trolls si il n'y a aucun troll en attente.
810 elire_troll() ->
811 {A1,A2,A3} = now(),
812 random:seed(A1, A2, A3),
813 mnesia:transaction(
814 fun() ->
815 case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined])) of
816 [] ->
817 plus_de_trolls;
818 Trolls ->
819 Troll = lists:nth(random:uniform(length(Trolls)), Trolls),
820 Troll2 = Troll#troll{date_post = now()},
821 mnesia:write(Troll2)
822 end
823 end
824 ).
825
826
827
828 update_version(1) ->
829 mnesia:transform_table(
830 ip_table,
831 fun() -> null end,
832 record_info(fields, ip_table),
833 ip_table
834 ).
835
836
837 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
838 resultat_transaction({_, T}) ->
839 T.
840
841
842 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
843 delta_date_ms(D1, D2) ->
844 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).
845
846 % Retourne la différence entre deux timestamp (erlang:now) en minutes
847 delta_date_minute(D1, D2) ->
848 trunc(delta_date_ms(D1, D2) / 1000 / 60).
849
850
851 % Bizarre, cette fonction n'existe pas dans la stdlib.
852 % Pas utilisé mais bon ca me fait de la peine de l'enlever.
853 ceiling(X) ->
854 T = trunc(X),
855 case (X - T) of
856 Neg when Neg < 0 -> T;
857 Pos when Pos > 0 -> T + 1;
858 _ -> T
859 end.
860
861
862 % Renvoie un nouvel id pour une table donnée
863 nouvel_id(Table) ->
864 mnesia:dirty_update_counter(counter, Table, 1).
865