a6099fefecc3bb9a31515e5f91cae31a9c9404fc
[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 users/0,
23 user_by_cookie/1,
24 user_by_id/1,
25 user_by_login/1,
26 user_by_login_password/2,
27 user_by_mess/1,
28 toggle_ek_master/1,
29
30 % messages :
31 nouveau_message/3,
32 nouveau_message_sys/1,
33 messages/1,
34 messages/2,
35 messages/3,
36 message_by_id/1,
37 messages_by_ids/1,
38 message_existe/1,
39 reponses/0,
40 repond_a/1,
41 est_une_reponse_a_user/2,
42 a_repondu_a_message/2,
43 possede_message/2,
44
45 % ip :
46 ip_table/0,
47 ban/2,
48 deban/1,
49 est_banni/1,
50 can_register/1,
51
52 % trolls :
53 trolls/0,
54 trolls/1,
55 trolls_attente/1,
56 put_troll/2,
57 mod_troll/2,
58 del_troll/1,
59 troll_by_id/1,
60 current_troll/0,
61 elire_troll/0,
62
63 % versions :
64 update_version/1,
65
66 % utiles :
67 resultat_transaction/1
68 ]).
69
70 -import(qlc, [e/1, e/2, q/1, cursor/1]).
71
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 % Renvoie tous les users.
245 users() ->
246 resultat_transaction(mnesia:transaction(fun() ->
247 e(q([E || E <- mnesia:table(user)]))
248 end)).
249
250
251 % Est-ce qu'un utilisateur existe en fonction de son cookie ?
252 % Renvoie {ok, User} ou erreur
253 user_by_cookie(Cookie) ->
254 resultat_transaction(mnesia:transaction(
255 fun() ->
256 case e(q([E || E <- mnesia:table(user), E#user.cookie =:= Cookie])) of
257 [User] -> {ok, User};
258 _ -> erreur
259 end
260 end
261 )).
262
263
264 user_by_id(ID) ->
265 resultat_transaction(mnesia:transaction(
266 fun() ->
267 case e(q([E || E <- mnesia:table(user), E#user.id =:= ID])) of
268 [User] -> {ok, User};
269 _ -> erreur
270 end
271 end
272 )).
273
274
275 user_by_login(Login) ->
276 resultat_transaction(mnesia:transaction(
277 fun() ->
278 Users = e(q([E || E <- mnesia:table(user), E#user.login =:= Login])),
279 case Users of
280 [User] -> {ok, User};
281 _ -> erreur
282 end
283 end
284 )).
285
286
287 toggle_ek_master(User_id) ->
288 resultat_transaction(mnesia:transaction(
289 fun() ->
290 Users = e(q([E || E <- mnesia:table(user), E#user.id =:= User_id])),
291 case Users of
292 [User] ->
293 mnesia:write(User#user{ek_master = not User#user.ek_master});
294 _ -> erreur
295 end
296 end
297 )).
298
299
300 user_by_login_password(Login, Password) ->
301 resultat_transaction(mnesia:transaction(
302 fun() ->
303 case e(q([E || E <- mnesia:table(user), E#user.login =:= Login, E#user.password =:= Password])) of
304 [User | _] -> {ok, User};
305 _ -> erreur
306 end
307 end
308 )).
309
310
311 % Renvoie {ok, User} où User est un #user possédant le message donné.
312 user_by_mess(Id) ->
313 resultat_transaction(mnesia:transaction(
314 fun() ->
315 case e(q([U || U <- mnesia:table(user), M <- mnesia:table(minichat), M#minichat.id =:= Id, M#minichat.auteur_id =:= U#user.id])) of
316 [User | _] -> {ok, User};
317 _ -> erreur
318 end
319 end
320 )).
321
322
323 % Ajoute un message. Repond_A est une liste d'id auquel le message répond
324 % retourne soit l'id du message soit erreur.
325 nouveau_message(Mess, Auteur_id, Repond_A) ->
326 % regarde si les id 'Repond_A' existent
327 F = fun() ->
328 Nb_id_trouve = length(e(q([E#minichat.id || E <- mnesia:table(minichat), lists:member(E#minichat.id, Repond_A)]))),
329 % est-ce que l'auteur existe ?
330 Auteur = case e(q([E || E <- mnesia:table(user), E#user.id =:= Auteur_id])) of
331 [A] -> A;
332 _ -> throw("L'auteur du message est introuvable")
333 end,
334 if Nb_id_trouve =/= length(Repond_A) -> throw("Un ou plusieurs messages introuvable");
335 true -> ok
336 end,
337 % compare les dernière
338 Delta = delta_date_ms(Auteur#user.date_derniere_connexion, now()),
339 Nouvel_indice_flood = Auteur#user.indice_flood + if Delta =< ?DUREE_SPAM -> 2; true -> -1 end,
340 Auteur_maj = Auteur#user{
341 indice_flood = if Nouvel_indice_flood > ?INDICE_SPAM_MAX -> ?INDICE_SPAM_MAX; Nouvel_indice_flood < 0 -> 0; true -> Nouvel_indice_flood end,
342 date_derniere_connexion = now()
343 },
344 % est-ce que l'auteur à trop floodé ?
345 if Auteur#user.indice_flood =/= ?INDICE_SPAM_MAX, Auteur_maj#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
346 mnesia:write(Auteur#user{indice_flood = Auteur_maj#user.indice_flood}),
347 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.");
348 Auteur#user.indice_flood =:= ?INDICE_SPAM_MAX, Delta =< ?DUREE_BLOCAGE_SPAM ->
349 erreur;
350 true ->
351 mnesia:write(Auteur_maj),
352 Id = nouvel_id(minichat),
353 inserer_reponses(Id, Repond_A),
354 mnesia:write(#minichat{id=Id, auteur_id=Auteur#user.id, date=now(), pseudo=Auteur#user.pseudo, contenu=Mess}),
355 Id
356 end
357 end,
358 resultat_transaction(mnesia:transaction(F)).
359
360 % Définit Id_repondant comme étant la réponse à Ids. Ids est une liste d'id.
361 inserer_reponses(Id_repondant, [Id_mess | Reste]) ->
362 mnesia:write(#reponse_minichat{repondant = Id_repondant, cible = Id_mess}),
363 inserer_reponses(Id_repondant, Reste);
364 inserer_reponses(_, []) ->
365 ok.
366
367
368 % Permet de créer un message système.
369 % Renvoie l'id du message système
370 nouveau_message_sys(Mess) ->
371 {ok, Root} = user_by_id(0),
372 mnesia:transaction(
373 fun() ->
374 Id = nouvel_id(minichat),
375 mnesia:write(#minichat{id=Id, auteur_id=0, date=now(), pseudo=Root#user.pseudo, contenu=Mess})
376 end
377 ).
378
379
380 % Renvoie N messages se trouvant sur la première page
381 messages(N) ->
382 messages(N, 1).
383
384
385 % Renvoie N messages se trouvant sur la page P
386 messages(N, P) ->
387 F = fun() ->
388 C = cursor(q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, descending}])])),
389 if P > 1 -> qlc:next_answers(C, N * (P - 1));
390 true -> ok
391 end,
392 R = qlc:next_answers(C, N),
393 qlc:delete_cursor(C),
394 lists:reverse(R)
395 end,
396 resultat_transaction(mnesia:transaction(F)).
397
398
399 % Renvoie les messages manquants pour la page P en sachant qu'il y a N message
400 % par page et que le dernier message que l'on possède est Id
401 messages(Id, N, P) ->
402 lists:filter(fun (M) -> M#minichat.id > Id end, messages(N, P)).
403
404
405 % Renvoie {ok, #minichat} (voir #minichat de euphorik_bd.hrl) à partir de son id.
406 message_by_id(Id) ->
407 case resultat_transaction(mnesia:transaction(
408 fun() ->
409 e(q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), Id =:= E#minichat.id]))
410 end
411 )) of
412 [M] -> {ok, M};
413 _ -> erreur
414 end.
415
416
417 % Renvoie une liste de message (voir #minichat de euphorik_bd.hrl) à partir d'une liste d'id (Ids).
418 messages_by_ids(Ids) ->
419 resultat_transaction(mnesia:transaction(
420 fun() ->
421 % TODO : optimisations ? serait-ce du O(n) ?
422 Query = q([E || E <- qlc:keysort(2, mnesia:table(minichat), [{order, ascending}]), lists:any(fun(Id) -> Id =:= E#minichat.id end, Ids)]),
423 e(Query)
424 end
425 )).
426
427
428 % Est-ce qu'un message existe ? Renvoie un boolean.
429 % TODO : ya pas plus simple ?
430 message_existe(Id) ->
431 resultat_transaction(mnesia:transaction(fun() ->
432 length(e(q([E#minichat.id || E <- mnesia:table(minichat), E#minichat.id =:= Id]))) =:= 1
433 end)).
434
435
436 % Renvoie les reponses (utilisé normalement uniquement pendant le debug).
437 reponses() ->
438 F = fun() ->
439 e(q([E || E <- mnesia:table(reponse_minichat)]))
440 end,
441 resultat_transaction(mnesia:transaction(F)).
442
443
444 % Renvoie les messages auquel M_id répond.
445 repond_a(M_id) ->
446 resultat_transaction(mnesia:transaction(
447 fun() ->
448 e(q(
449 [M || E <- mnesia:table(reponse_minichat),
450 M <- mnesia:table(minichat),
451 E#reponse_minichat.repondant =:= M_id,
452 M#minichat.id =:= E#reponse_minichat.cible]))
453 end
454 )).
455
456
457 % Est-ce que le message Id_mess est une réponse d'une message de Id_user ?
458 est_une_reponse_a_user(Id_user, Id_mess) ->
459 case mnesia:transaction(
460 fun() ->
461 e(q([
462 M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
463 M#minichat.auteur_id =:= Id_user, M#minichat.id =:= R#reponse_minichat.cible, R#reponse_minichat.repondant =:= Id_mess
464 ]), [{unique_all, true}])
465 end
466 ) of
467 {atomic, [_]} -> true;
468 _ -> false
469 end.
470
471
472 % Est-ce que Id_user à répondu au message Id_mess
473 a_repondu_a_message(Id_user, Id_mess) ->
474 case mnesia:transaction(
475 fun() ->
476 e(q([
477 M#minichat.auteur_id || M <- mnesia:table(minichat), R <- mnesia:table(reponse_minichat),
478 R#reponse_minichat.cible =:= Id_mess, R#reponse_minichat.repondant =:= M#minichat.id, M#minichat.auteur_id =:= Id_user
479 ]), [{unique_all, true}])
480 end
481 ) of
482 {atomic, [_]} -> true;
483 _ -> false
484 end.
485
486
487 % Est-ce que Id_user possède Id_mess ?
488 possede_message(Id_user, Id_mess) ->
489 case mnesia:transaction(
490 fun() ->
491 e(q([E#minichat.auteur_id || E <- mnesia:table(minichat), E#minichat.id =:= Id_mess]))
492 end
493 ) of
494 {atomic, [Id_user | []]} -> true;
495 _ -> false
496 end.
497
498
499 ip_table() ->
500 resultat_transaction(mnesia:transaction(
501 fun() ->
502 e(q([IP || IP <- mnesia:table(ip_table)]))
503 end
504 )).
505
506
507 % Bannie une ip pour un certain temps (en minute).
508 ban(IP, Duration) ->
509 mnesia:transaction(
510 fun() ->
511 case mnesia:wread({ip_table, IP}) of
512 [IP_tuple] ->
513 mnesia:write(IP_tuple#ip_table{ban = now(), ban_duration = Duration});
514 _ ->
515 mnesia:write(#ip_table{ip = IP, ban = now(), ban_duration = Duration})
516 end
517 end
518 ).
519
520
521 % Débanni une ip
522 deban(IP) ->
523 ban(IP, 0).
524
525
526 % Renvoie soit {true, Temps} où Temps est le temps en minutes pendant lequel le user est encore banni
527 % ou false.
528 est_banni(User_id) ->
529 resultat_transaction(mnesia:transaction(
530 fun() ->
531 case e(q([
532 {IP#ip_table.ban, IP#ip_table.ban_duration} ||
533 U <- mnesia:table(user),
534 U#user.id =:= User_id,
535 IP <- mnesia:table(ip_table),
536 IP#ip_table.ip =:= U#user.last_ip
537 ])) of
538 [{Ban, Ban_duration}] ->
539 Echeance = date_plus_minutes(Ban, Ban_duration),
540 Now = now(),
541 if Echeance < Now -> % l'échéance est passée
542 false;
543 true ->
544 {true, trunc(delta_date_ms(Echeance, Now) / 1000 / 60)}
545 end;
546 _ ->
547 false
548 end
549 end
550 )).
551
552
553 % Ban est une date tel que retourner par now().
554 % Ban_duration est un temps en minutes.
555 % retourne une date.
556 date_plus_minutes(Ban, Ban_duration) ->
557 Duration_sec = Ban_duration * 60,
558 {MegaSec, Sec, MicroSec} = Ban,
559 {MegaSec + if Sec + Duration_sec >= 1000000 -> 1; true -> 0 end,(Sec + Duration_sec) rem 1000000, MicroSec}.
560
561
562 % Si deux enregistrements consequtifs de la même IP sont fait en moins d'une seconde alors
563 % ip_table.nb_try_register est incrémenté de 1 sinon il est décrémenté de 1 (jusqu'a 0).
564 % Si ip_table.nb_try_register vaut 5 alors l'ip ne peux plus s'enregistrer pour une heure.
565 can_register(IP) ->
566 resultat_transaction(mnesia:transaction(
567 fun() ->
568 case e(q([I || I <- mnesia:table(ip_table), I#ip_table.ip =:= IP])) of
569 [] ->
570 mnesia:write(#ip_table{ip = IP, date_last_try_register = now()}),
571 true;
572 [T] ->
573 Delta = delta_date_ms(T#ip_table.date_last_try_register, now()),
574 if T#ip_table.nb_try_register =:= ?NB_MAX_FLOOD_REGISTER, Delta < ?TEMPS_BAN_FLOOD_REGISTER ->
575 false;
576 true ->
577 mnesia:write(#ip_table{
578 ip = IP,
579 date_last_try_register = now(),
580 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
581 }),
582 true
583 end
584 end
585 end
586 )).
587
588
589 % Renvoie tous les trolls.
590 trolls() ->
591 resultat_transaction(mnesia:transaction(
592 fun() ->
593 e(q([T || T <- qlc:keysort(2, mnesia:table(troll))]))
594 end
595 )).
596
597
598 % Renvoie les trolls manquants posté après Last_id.
599 trolls(Last_id) ->
600 resultat_transaction(mnesia:transaction(
601 e(q([T || T <- qlc:keysort(2, mnesia:table(troll)), T#troll.id > Last_id, T#troll.date_post =:= undefined]))
602 )).
603
604
605 % Renvoie les trolls manquants posté après Last_id.
606 % Si pas de trolls alors attend un événement tel qu'un ajout, une modification ou une suppression.
607 % renvoie :
608 % {mod, Troll}
609 % ou {add, [Trolls]}
610 % ou {del, Troll_id}
611 % ou timeout
612 trolls_attente(Last_id) ->
613 case mnesia:subscribe({table, troll, detailed}) of
614 {error, E} = E ->
615 E;
616 _ ->
617 R = case resultat_transaction(mnesia:transaction(
618 fun() ->
619 e(q([T || T <- qlc:keysort(2, mnesia:table(troll)), T#troll.id > Last_id, T#troll.date_post =:= undefined]))
620 end
621 )) of
622 [] -> % pas de trolls
623 attend_evenement_troll();
624 Trolls ->
625 {add, Trolls}
626 end,
627 mnesia:unsubscribe({table, troll, detailed}),
628 R
629 end.
630
631 attend_evenement_troll() ->
632 % s'il n'y a pas de trolls que l'utilisateur n'a pas connaissance alors on attend un événement
633 receive
634 % cas où un troll est choisit comme courant
635 {mnesia_table_event, {write, troll, Troll, [Old_troll | _], _}} when Old_troll#troll.date_post =:= undefined, Troll#troll.date_post =/= undefined ->
636 {del, Troll#troll.id};
637 {mnesia_table_event, {write, troll, Troll, [_Old_troll | _], _}} ->
638 {mod, Troll};
639 {mnesia_table_event, {write, troll, Troll, [], _}} ->
640 {add, [Troll]};
641 {mnesia_table_event, {delete, troll, {troll, Id}, _, _}} ->
642 {del, Id};
643 {tcp_closed, _} ->
644 exit(normal);
645 _ ->
646 attend_evenement_troll()
647 % 60 minutes de timeout (on ne sais jamais)
648 % Après 60 minutes de connexion, le client doit donc reétablir une connexion
649 after 1000 * 60 * 60 ->
650 timeout
651 end.
652
653
654 % Renvoie l'id du nouveau troll
655 % ou max_troll_reached_per_user si le nombre de troll posté par l'utilisateur max a été atteind
656 % ou max_troll_reached si le nombre de troll posté max a été atteind
657 % ou user_unknown
658 put_troll(User_id, Content) ->
659 resultat_transaction(mnesia:transaction(
660 fun() ->
661 % control le nombre de troll déjà posté
662 Nb_troll_poste_par_user = length(e(q(
663 [
664 E#troll.id || E <- mnesia:table(troll),
665 E#troll.id_user =:= User_id,
666 E#troll.date_post =:= undefined
667 ]
668 ))),
669 Nb_troll_poste_total = length(e(q(
670 [
671 E#troll.id || E <- mnesia:table(troll),
672 E#troll.date_post =:= undefined
673 ]
674 ))),
675 User = user_by_id(User_id),
676 case User of
677 {ok, _} ->
678 if Nb_troll_poste_par_user >= ?NB_MAX_TROLL_WAITING_BY_USER ->
679 max_troll_reached_per_user;
680 Nb_troll_poste_total >= ?NB_MAX_TROLL_WAITING ->
681 max_troll_reached;
682 true ->
683 Id = nouvel_id(minichat),
684 mnesia:write(#troll{id = Id, id_user = User_id, date_create = now(), content = Content}),
685 Id
686 end;
687 _ ->
688 user_unknown
689 end
690 end
691 )).
692
693
694 % renvoie ok | erreur
695 mod_troll(Troll_id, Content) ->
696 mnesia:transaction(
697 fun() ->
698 case mnesia:wread({troll, Troll_id}) of
699 [Troll = #troll{date_post = undefined}] ->
700 mnesia:write(Troll#troll{content = Content});
701 _ ->
702 mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
703 end
704 end
705 ).
706
707
708 del_troll(Troll_id) ->
709 mnesia:transaction(
710 fun() ->
711 case mnesia:wread({troll, Troll_id}) of
712 [#troll{date_post = undefined}] ->
713 mnesia:delete({troll, Troll_id});
714 _ ->
715 mnesia:abort("mod_troll: Troll inconnu ou déjà posté")
716 end
717 end
718 ).
719
720
721 troll_by_id(Troll_id) ->
722 resultat_transaction(mnesia:transaction(
723 fun() ->
724 case e(q([T || T <- mnesia:table(troll), T#troll.id =:= Troll_id])) of
725 [T] -> {ok, T};
726 _ ->
727 erreur
728 end
729 end
730 )).
731
732
733 % Renvoie le troll actuel qui se trouve sur la page principale.
734 % Renvois aucun si pas de troll courant.
735 current_troll() ->
736 resultat_transaction(mnesia:transaction(
737 fun() ->
738 % TODO : ya pas moyen de désigner le champs plutot qu'avec un nombre pour le tri ?
739 C = cursor(q([T || T <- qlc:keysort(5, mnesia:table(troll), [{order, descending}]), T#troll.date_post =/= undefined])),
740 R = case qlc:next_answers(C, 1) of
741 [T] -> T;
742 _ -> aucun
743 end,
744 qlc:delete_cursor(C),
745 R
746 end
747 )).
748
749
750 % Elit un troll au hasard parmis les trolls en attente (leur date_post =:= undefined)
751 % met à jour sa date de post.
752 % renvoie plus_de_trolls si il n'y a aucun troll en attente.
753 elire_troll() ->
754 {A1,A2,A3} = now(),
755 random:seed(A1, A2, A3),
756 mnesia:transaction(
757 fun() ->
758 case e(q([T || T <- mnesia:table(troll), T#troll.date_post =:= undefined])) of
759 [] ->
760 plus_de_trolls;
761 Trolls ->
762 Troll = lists:nth(random:uniform(length(Trolls)), Trolls),
763 Troll2 = Troll#troll{date_post = now()},
764 mnesia:write(Troll2)
765 end
766 end
767 ).
768
769
770
771 update_version(1) ->
772 mnesia:transform_table(
773 ip_table,
774 fun() -> null end,
775 record_info(fields, ip_table),
776 ip_table
777 ).
778
779
780 % Renvoie le résultat d'une transaction (en décomposant le tuple fournit)
781 resultat_transaction({_, T}) ->
782 T.
783
784
785 % Retourne la difference entre deux timestamp (erlang:now()) en miliseconde
786 delta_date_ms(D1, D2) ->
787 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).
788
789
790 % Bizarre, cette fonction n'existe pas dans la stdlib.
791 % Pas utilisé mais bon ca me fait de la peine de l'enlever.
792 ceiling(X) ->
793 T = trunc(X),
794 case (X - T) of
795 Neg when Neg < 0 -> T;
796 Pos when Pos > 0 -> T + 1;
797 _ -> T
798 end.
799
800
801 % Renvoie un nouvel id pour une table donnée
802 nouvel_id(Table) ->
803 mnesia:dirty_update_counter(counter, Table, 1).
804