ADD fin de la page admin
[euphorik.git] / js / euphorik.js
1 // coding: utf-8
2
3 /**
4 * Contient la base javascript pour le site euphorik.ch.
5 * Chaque page possède son propre fichier js nommé "page<nom de la page>.js".
6 * Auteur : GBurri
7 * Date : 6.11.2007
8 */
9
10
11 /**
12 * La configuration.
13 * Normalement 'const' à la place de 'var' mais non supporté par IE7.
14 */
15 var conf = {
16 nbMessageAffiche : 40, // (par page)
17 pseudoDefaut : "<nick>",
18 tempsAffichageMessageDialogue : 4000, // en ms
19 smiles : {
20 "smile" : [/:\)/g, /:-\)/g],
21 "bigsmile" : [/:D/g, /:-D/g],
22 "clin" : [/;\)/g, /;-\)/g],
23 "cool" : [/8\)/g, /8-\)/g],
24 "eheheh" : [/:P/g, /:-P/g],
25 "lol" : [/\[-lol\]/g],
26 "spliff" : [/\[-spliff\]/g],
27 "oh" : [/:o/g, /:O/g],
28 "heink" : [/\[-heink\]/g],
29 "hum" : [/\[-hum\]/g],
30 "boh" : [/\[-boh\]/g],
31 "sniff" : [/:\(/g, /:-\(/g],
32 "triste" : [/\[-triste\]/g],
33 "pascontent" : [/>\(/g, /&gt;\(/g],
34 "argn" : [/\[-argn\]/g],
35 "redface" : [/\[-redface\]/g],
36 "bunny" : [/\[-lapin\]/g],
37 "chat" : [/\[-chat\]/g],
38 "renne" : [/\[-renne\]/g],
39 "star" : [/\[-star\]/g],
40 "kirby" : [/\[-kirby\]/g],
41 "slurp" : [/\[-slurp\]/g],
42 "agreed" : [/\[-agreed\]/g],
43 "dodo" : [/\[-dodo\]/g],
44 "bn" : [/\[-bn\]/g]
45 }
46 }
47
48 ///////////////////////////////////////////////////////////////////////////////////////////////////
49
50 String.prototype.trim = function()
51 {
52 return jQuery.trim(this) // anciennement : this.replace(/^\s+|\s+$/g, "");
53 }
54
55 String.prototype.ltrim = function()
56 {
57 return this.replace(/^\s+/, "");
58 }
59
60 String.prototype.rtrim = function()
61 {
62 return this.replace(/\s+$/, "");
63 }
64
65 ///////////////////////////////////////////////////////////////////////////////////////////////////
66
67 /**
68 * Cette classe regroupe des fonctions utilitaires (helpers).
69 * @formateur est permet de formater les messages affichés à l'aide de messageDialogue (facultatif)
70 */
71 function Util(formateur)
72 {
73 $("#info .fermer").click(function(){
74 $("#info").slideUp(50)
75 })
76
77 this.formateur = formateur
78 }
79
80 var messageType = {informatif: 0, question: 1, erreur: 2}
81
82 /**
83 * Affiche une boite de dialogue avec un message à l'intérieur.
84 * @param message le message (string)
85 * @param type voir 'messageType'. par défaut messageType.informatif
86 * @param les boutons sous la forme d'un objet ou les clefs sont les labels des boutons
87 * et les valeurs les fonctions executées lorsqu'un bouton est activé.
88 * @param formate faut-il formaté le message ? true par défaut
89 */
90 Util.prototype.messageDialogue = function(message, type, boutons, formate)
91 {
92 var thisUtil = this
93
94 if (type == undefined)
95 type = messageType.informatif
96
97 if (formate == undefined)
98 formate = true
99
100 if (this.timeoutMessageDialogue != undefined)
101 clearTimeout(this.timeoutMessageDialogue)
102
103 var fermer = function(){$("#info").slideUp(100)}
104 fermer()
105
106 $("#info .message").html(thisUtil.formateur == undefined || !formate ? message : thisUtil.formateur.traitementComplet(message))
107 switch(type)
108 {
109 case messageType.informatif : $("#info #icone").attr("class", "information"); break
110 case messageType.question : $("#info #icone").attr("class", "interrogation"); break
111 case messageType.erreur : $("#info #icone").attr("class", "exclamation"); break
112 }
113 $("#info .boutons").html("")
114 for (var b in boutons)
115 $("#info .boutons").append("<div>" + b + "</div>").find("div:last").click(boutons[b]).click(fermer)
116
117 $("#info").slideDown(200)
118 this.timeoutMessageDialogue = setTimeout(fermer, conf.tempsAffichageMessageDialogue)
119 }
120
121 /**
122 * Utilisé pour l'envoie de donnée avec la méthode ajax de jQuery.
123 */
124 Util.prototype.jsonVersAction = function(json)
125 {
126 return {action : JSON.stringify(json) }
127 }
128
129 Util.prototype.md5 = function(chaine)
130 {
131 return hex_md5(chaine)
132 }
133
134 // pompé de http://www.faqts.com/knowledge_base/view.phtml/aid/13562/fid/130
135 Util.prototype.setSelectionRange = function(input, selectionStart, selectionEnd)
136 {
137 if (input.setSelectionRange)
138 {
139 input.focus()
140 input.setSelectionRange(selectionStart, selectionEnd)
141 }
142 else if (input.createTextRange)
143 {
144 var range = input.createTextRange()
145 range.collapse(true)
146 range.moveEnd('character', selectionEnd)
147 range.moveStart('character', selectionStart)
148 range.select()
149 }
150 }
151
152 Util.prototype.setCaretToEnd = function(input)
153 {
154 this.setSelectionRange(input, input.value.length, input.value.length)
155 }
156 Util.prototype.setCaretToBegin = function(input)
157 {
158 this.setSelectionRange(input, 0, 0)
159 }
160 Util.prototype.setCaretToPos = function(input, pos)
161 {
162 this.setSelectionRange(input, pos, pos)
163 }
164 Util.prototype.selectString = function(input, string)
165 {
166 var match = new RegExp(string, "i").exec(input.value)
167 if (match)
168 {
169 this.setSelectionRange (input, match.index, match.index + match[0].length)
170 }
171 }
172 Util.prototype.replaceSelection = function(input, replaceString) {
173 if (input.setSelectionRange)
174 {
175 var selectionStart = input.selectionStart
176 var selectionEnd = input.selectionEnd
177 input.value = input.value.substring(0, selectionStart) + replaceString + input.value.substring(selectionEnd)
178
179 if (selectionStart != selectionEnd) // has there been a selection
180 this.setSelectionRange(input, selectionStart, selectionStart + replaceString.length)
181 else // set caret
182 this.setCaretToPos(input, selectionStart + replaceString.length)
183 }
184 else if (document.selection)
185 {
186 var range = document.selection.createRange();
187 if (range.parentElement() == input)
188 {
189 var isCollapsed = range.text == ''
190 range.text = replaceString
191 if (!isCollapsed)
192 {
193 // there has been a selection
194 // it appears range.select() should select the newly
195 // inserted text but that fails with IE
196 range.moveStart('character', -replaceString.length);
197 range.select();
198 }
199 }
200 }
201 }
202
203 Util.prototype.rot13 = function(chaine)
204 {
205 var ACode = 'A'.charCodeAt(0)
206 var aCode = 'a'.charCodeAt(0)
207 var MCode = 'M'.charCodeAt(0)
208 var mCode = 'm'.charCodeAt(0)
209 var ZCode = 'Z'.charCodeAt(0)
210 var zCode = 'z'.charCodeAt(0)
211
212 var f = function(ch, pos) {
213 if (pos == ch.length)
214 return ""
215
216 var c = ch.charCodeAt(pos);
217 return String.fromCharCode(
218 c +
219 (c >= ACode && c <= MCode || c >= aCode && c <= mCode ? 13 :
220 (c > MCode && c <= ZCode || c > mCode && c <= zCode ? -13 : 0))
221 ) + f(ch, pos + 1)
222 }
223 return f(chaine, 0)
224 }
225
226 ///////////////////////////////////////////////////////////////////////////////////////////////////
227
228 function Pages()
229 {
230 this.pageCourante = null
231 this.pages = {}
232 }
233
234 Pages.prototype.ajouterPage = function(page)
235 {
236 page.pages = this // la magie des langages dynamiques : le foutoire
237 this.pages[page.nom] = page
238 }
239
240 Pages.prototype.afficherPage = function(nomPage, forcerChargement)
241 {
242 if (forcerChargement == undefined) forcerChargement = false
243
244 var page = this.pages[nomPage]
245 if (page == undefined || (!forcerChargement && page == this.pageCourante)) return
246
247 if (this.pageCourante != null && this.pageCourante.decharger)
248 this.pageCourante.decharger()
249
250 $("#menu div").removeClass("courante")
251 $("#menu div." + nomPage).addClass("courante")
252
253 this.pageCourante = page
254 $("#page").html(this.pageCourante.contenu()).removeClass().addClass(this.pageCourante.nom)
255
256 if (this.pageCourante.charger)
257 this.pageCourante.charger()
258 }
259
260 ///////////////////////////////////////////////////////////////////////////////////////////////////
261
262 /**
263 * Classe permettant de formater du texte par exemple pour la substitution des liens dans les
264 * message par "[url]".
265 * TODO : améliorer l'efficacité des méthods notamment lié au smiles.
266 */
267 function Formateur()
268 {
269 this.smiles = conf.smiles
270 this.protocoles = "http|https|ed2k"
271
272 this.regexUrl = new RegExp("(?:(?:" + this.protocoles + ")://|www\\.)[^ ]*", "gi")
273 this.regexImg = new RegExp("^.*?\\.(gif|jpg|png|jpeg|bmp|tiff)$", "i")
274 this.regexDomaine = new RegExp("^(?:(?:" + this.protocoles + ")://|www\\.).*?([^/.]+\\.[^/.]+)(?:$|/).*$", "i")
275 this.regexTestProtocoleExiste = new RegExp("^(?:" + this.protocoles + ")://.*$", "i")
276 this.regexNomProtocole = new RegExp("^(.*?)://")
277 }
278
279 /**
280 * Formate un pseudo saise par l'utilisateur.
281 * @param pseudo le pseudo brut
282 * @return le pseudo filtré
283 */
284 Formateur.prototype.filtrerInputPseudo = function(pseudo)
285 {
286 return pseudo.replace(/{|}/g, "").trim()
287 }
288
289 Formateur.prototype.getSmilesHTML = function()
290 {
291 var XHTML = ""
292 for (var sNom in this.smiles)
293 {
294 XHTML += "<img class=\"" + sNom + "\" src=\"img/smileys/" + sNom + ".gif\" alt =\"" + sNom + "\" />"
295 }
296 return XHTML
297 }
298
299 /**
300 * Formatage complet d'un texte.
301 * @M le message
302 * @pseudo facultatif, permet de contruire le label des images sous la forme : "<Pseudo> : <Message>"
303 */
304 Formateur.prototype.traitementComplet = function(M, pseudo)
305 {
306 return this.traiterLiensConv(this.traiterSmiles(this.traiterURL(this.traiterWikiSyntaxe(this.remplacerBalisesHTML(M)), pseudo)))
307 }
308
309 /**
310 * Transforme les liens en entités clickables.
311 * Un lien vers une conversation permet d'ouvrire celle ci, elle se marque comme ceci dans un message :
312 * "{5F}" ou 5F est la racine de la conversation.
313 * Ce lien sera transformer en <span class="lienConv">{5F}</span> pouvant être clické pour créer la conv 5F.
314 */
315 Formateur.prototype.traiterLiensConv = function(M)
316 {
317 return M.replace(
318 /\{\w+\}/g,
319 function(lien)
320 {
321 return "<span class=\"lienConv\">" + lien + "</span>"
322 }
323 )
324 }
325
326 /**
327 * FIXME : Cette méthode est attrocement lourde ! A optimiser.
328 * moyenne sur échantillon : 234ms
329 */
330 Formateur.prototype.traiterSmiles = function(M)
331 {
332 for (var sNom in this.smiles)
333 {
334 ss = this.smiles[sNom]
335 for (var i = 0; i < ss.length; i++)
336 M = M.replace(ss[i], "<img src=\"img/smileys/" + sNom + ".gif\" alt =\"" + sNom + "\" />")
337 }
338 return M
339 }
340
341 Formateur.prototype.remplacerBalisesHTML = function(M)
342 {
343 return M.replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;")
344 }
345
346 Formateur.prototype.traiterURL = function(M, pseudo)
347 {
348 thisFormateur = this
349
350 var traitementUrl = function(url)
351 {
352 // si ya pas de protocole on rajoute "http://"
353 if (!thisFormateur.regexTestProtocoleExiste.test(url))
354 url = "http://" + url
355 var extension = thisFormateur.getShort(url)
356 return "<a " + (extension[1] ? "title=\"" + (pseudo == undefined ? "" : thisFormateur.traiterPourFenetreLightBox(pseudo, url) + ": ") + thisFormateur.traiterPourFenetreLightBox(M, url) + "\"" + " rel=\"lightbox\"" : "") + " href=\"" + url + "\" >[" + extension[0] + "]</a>"
357 }
358 return M.replace(this.regexUrl, traitementUrl)
359 }
360
361 /**
362 * Formatage en utilisant un sous-ensemble des règles de mediwiki.
363 * par exemple ''italic'' devient <i>italic</i>
364 */
365 Formateur.prototype.traiterWikiSyntaxe = function(M)
366 {
367 return M.replace(
368 /'''(.*?)'''/g,
369 function(texte, capture)
370 {
371 return "<b>" + capture + "</b>"
372 }
373 ).replace(
374 /''(.*?)''/g,
375 function(texte, capture)
376 {
377 return "<i>" + capture + "</i>"
378 }
379 )
380 }
381
382 /**
383 * Renvoie une version courte de l'url.
384 * par exemple : http://en.wikipedia.org/wiki/Yakov_Smirnoff devient wikipedia.org
385 */
386 Formateur.prototype.getShort = function(url)
387 {
388 var estUneImage = false
389 var versionShort = null
390 var rechercheImg = this.regexImg.exec(url)
391
392 if (rechercheImg != null)
393 {
394 versionShort = rechercheImg[1].toLowerCase()
395 if (versionShort == "jpeg") versionShort = "jpg" // jpeg -> jpg
396 estUneImage = true
397 }
398 else
399 {
400 var rechercheDomaine = this.regexDomaine.exec(url)
401 if (rechercheDomaine != null && rechercheDomaine.length >= 2)
402 versionShort = rechercheDomaine[1]
403 else
404 {
405 var nomProtocole = this.regexNomProtocole.exec(url)
406 if (nomProtocole != null && nomProtocole.length >= 2)
407 versionShort = nomProtocole[1]
408 }
409 }
410
411 return [versionShort == null ? "url" : versionShort, estUneImage]
412 }
413
414 /**
415 * Traite les pseudo et messages à être affiché dans le titre d'une image visualisé avec lightbox.
416 */
417 Formateur.prototype.traiterPourFenetreLightBox = function(M, urlCourante)
418 {
419 thisFormateur = this
420 var traitementUrl = function(url)
421 {
422 return "[" + thisFormateur.getShort(url)[0] + (urlCourante == url ? "*" : "") + "]"
423 }
424
425 return this.remplacerBalisesHTML(M).replace(this.regexUrl, traitementUrl)
426 }
427
428
429 ///////////////////////////////////////////////////////////////////////////////////////////////////
430
431 // les statuts possibes du client
432 var statutType = {
433 // mode enregistré, peut poster des messages et modifier son profile
434 auth_registered : 0,
435 // mode identifié, peut poster des messages mais n'a pas accès au profile
436 auth_not_registered : 1,
437 // mode déconnecté, ne peut pas poster de message
438 deconnected : 2
439 }
440
441 function Client(util)
442 {
443 this.util = util
444
445 this.cookie = null
446 this.regexCookie = new RegExp("^cookie=([^;]*)")
447
448 // données personnels
449 this.resetDonneesPersonnelles()
450
451 this.setStatut(statutType.deconnected)
452 }
453
454 Client.prototype.resetDonneesPersonnelles = function()
455 {
456 this.id = 0
457 this.pseudo = conf.pseudoDefaut
458 this.login = ""
459 this.password = ""
460 this.email = ""
461 this.css = $("link#cssPrincipale").attr("href")
462 this.nickFormat = "nick"
463 this.cookie = undefined
464
465 this.pagePrincipale = 1
466 this.ekMaster = false
467
468 // les conversations, une conversation est un objet possédant les attributs suivants :
469 // - racine (entier)
470 // - page (entier)
471 this.conversations = new Array()
472 }
473
474 Client.prototype.setCss = function(css)
475 {
476 if (this.css == css || css == "")
477 return
478
479 this.css = css
480 $("link#cssPrincipale").attr("href", this.css)
481 this.majMenu()
482 }
483
484 Client.prototype.pageSuivante = function(numConv)
485 {
486 if (numConv < 0 && this.pagePrincipale > 1)
487 this.pagePrincipale -= 1
488 else if (this.conversations[numConv].page > 1)
489 this.conversations[numConv].page -= 1
490 }
491
492 Client.prototype.pagePrecedente = function(numConv)
493 {
494 if (numConv < 0)
495 this.pagePrincipale += 1
496 else
497 this.conversations[numConv].page += 1
498 }
499
500 /**
501 * Définit la première page pour la conversation donnée.
502 * @return true si la page a changé sinon false
503 */
504 Client.prototype.goPremierePage = function(numConv)
505 {
506 if (numConv < 0)
507 {
508 if (this.pagePrincipale == 1)
509 return false
510 this.pagePrincipale = 1
511 }
512 else
513 {
514 if (this.conversations[numConv].page == 1)
515 return false
516 this.conversations[numConv].page = 1
517 }
518 return true
519 }
520
521 /**
522 * Ajoute une conversation à la vue de l'utilisateur.
523 * Le profile de l'utilisateur est directement sauvegardé sur le serveur.
524 * @param racines la racine de la conversation (integer)
525 * @return true si la conversation a été créée sinon false (par exemple si la conv existe déjà)
526 */
527 Client.prototype.ajouterConversation = function(racine)
528 {
529 // vérification s'il elle n'existe pas déjà
530 for (var i = 0; i < this.conversations.length; i++)
531 if (this.conversations[i].root == racine)
532 return false
533
534 this.conversations.push({root : racine, page : 1})
535 return true
536 }
537
538 Client.prototype.supprimerConversation = function(num)
539 {
540 if (num < 0 || num >= this.conversations.length) return
541
542 // décalage TODO : supprimer le dernier élément
543 for (var i = num; i < this.conversations.length - 1; i++)
544 this.conversations[i] = this.conversations[i+1]
545 this.conversations.pop()
546 }
547
548 Client.prototype.getJSONLogin = function(login, password)
549 {
550 return {
551 "action" : "authentification",
552 "login" : login,
553 "password" : password
554 }
555 }
556
557 Client.prototype.getJSONLoginCookie = function()
558 {
559 return {
560 "action" : "authentification",
561 "cookie" : this.cookie
562 }
563 }
564
565 /**
566 * le couple (login, password) est facultatif. S'il n'est pas fournit alors il ne sera pas possible
567 * de s'autentifier avec (login, password).
568 */
569 Client.prototype.getJSONEnregistrement = function(login, password)
570 {
571 var mess = { "action" : "register" }
572
573 if (login != undefined && password != undefined)
574 {
575 mess["login"] = login
576 mess["password"] = password
577 }
578
579 return mess;
580 }
581
582 Client.prototype.getJSONConversations = function()
583 {
584 var conversations = new Array()
585 for (var i = 0; i < this.conversations.length; i++)
586 conversations.push({ "root" : this.conversations[i].root, "page" : this.conversations[i].page})
587 return conversations
588 }
589
590 Client.prototype.getJSONProfile = function()
591 {
592 return {
593 "action" : "set_profile",
594 "cookie" : this.cookie,
595 "login" : this.login,
596 "password" : this.password,
597 "nick" : this.pseudo,
598 "email" : this.email,
599 "css" : this.css,
600 "nick_format" : this.nickFormat,
601 "main_page" : this.pagePrincipale < 1 ? 1 : this.pagePrincipale,
602 "conversations" : this.getJSONConversations()
603 }
604 }
605
606 /**
607 * Renvoie null si pas définit.
608 */
609 Client.prototype.getCookie = function()
610 {
611 var cookie = this.regexCookie.exec(document.cookie)
612 if (cookie == null) this.cookie = null
613 else this.cookie = cookie[1]
614 }
615
616 Client.prototype.delCookie = function()
617 {
618 document.cookie = "cookie=; max-age=0"
619 }
620
621 Client.prototype.setCookie = function(cookie)
622 {
623 if (this.cookie == null)
624 return
625
626 document.cookie =
627 "cookie="+this.cookie+
628 "; max-age=" + (60 * 60 * 24 * 365)
629 }
630
631 Client.prototype.authentifie = function()
632 {
633 return this.statut == statutType.auth_registered || this.statut == statutType.auth_not_registered
634 }
635
636 Client.prototype.setStatut = function(statut)
637 {
638 // conversation en "enum" si en "string"
639 if (typeof(statut) == "string")
640 {
641 statut =
642 statut == "auth_registered" ?
643 statutType.auth_registered :
644 (statut == "auth_not_registered" ? statutType.auth_not_registered : statutType.deconnected)
645 }
646
647 if (statut == this.statut) return
648
649 this.statut = statut
650 this.majMenu()
651 }
652
653 /**
654 * Effectue la connexion vers le serveur.
655 * Cette fonction est bloquante tant que la connexion n'a pas été établie.
656 * S'il existe un cookie en local on s'authentifie directement avec lui.
657 * Si il n'est pas possible de s'authentifier alors on affiche un captcha anti-bot.
658 */
659 Client.prototype.connexionCookie = function()
660 {
661 this.getCookie()
662 if (this.cookie == null) return false;
663 return this.connexion(this.getJSONLoginCookie())
664 }
665
666 Client.prototype.connexionLogin = function(login, password)
667 {
668 return this.connexion(this.getJSONLogin(login, password))
669 }
670
671 Client.prototype.enregistrement = function(login, password)
672 {
673 if (this.authentifie())
674 {
675 this.login = login
676 this.password = password
677 if(this.flush())
678 {
679 this.setStatut(statutType.auth_registered)
680 return true
681 }
682 return false
683 }
684 else
685 {
686 return this.connexion(this.getJSONEnregistrement(login, password))
687 }
688 }
689
690 Client.prototype.connexion = function(messageJson)
691 {
692 ;;; dumpObj(messageJson)
693 thisClient = this
694 jQuery.ajax(
695 {
696 async: false,
697 type: "POST",
698 url: "request",
699 dataType: "json",
700 data: this.util.jsonVersAction(messageJson),
701 success:
702 function(data)
703 {
704 ;;; dumpObj(data)
705 if (data["reply"] == "error")
706 thisClient.util.messageDialogue(data["error_message"])
707 else
708 thisClient.chargerDonnees(data)
709 }
710 }
711 )
712 return this.authentifie()
713 }
714
715 Client.prototype.deconnexion = function()
716 {
717 this.flush(true)
718 this.delCookie()
719 this.resetDonneesPersonnelles()
720 this.setStatut(statutType.deconnected) // deconnexion
721 }
722
723 Client.prototype.chargerDonnees = function(data)
724 {
725 // la modification du statut qui suit met à jour le menu, le menu dépend (page admin)
726 // de l'état ekMaster
727 this.ekMaster = data["ek_master"] != undefined ? data["ek_master"] : false
728
729 this.setStatut(data["status"])
730
731 if (this.authentifie())
732 {
733 this.cookie = data["cookie"]
734 this.setCookie()
735
736 this.id = data["id"]
737 this.login = data["login"]
738 this.pseudo = data["nick"]
739 this.email = data["email"]
740 this.setCss(data["css"])
741 this.nickFormat = data["nick_format"]
742
743 // la page de la conversation principale
744 this.pagePrincipale = data["main_page"] == undefined ? 1 : data["main_page"]
745
746 // les conversations
747 this.conversations = data["conversations"]
748 }
749 }
750
751 /**
752 * Met à jour les données personne sur serveur.
753 * @param async de manière asynchrone ? défaut = true
754 * @return false si le flush n'a pas pû se faire sinon true
755 */
756 Client.prototype.flush = function(async)
757 {
758 if (async == undefined)
759 async = false
760
761 if (!this.authentifie())
762 return false
763
764 var thisClient = this
765 var ok = true
766
767 ;;; dumpObj(this.getJSONProfile())
768 jQuery.ajax(
769 {
770 async: async,
771 type: "POST",
772 url: "request",
773 dataType: "json",
774 data: this.util.jsonVersAction(this.getJSONProfile()),
775 success:
776 function(data)
777 {
778 ;;; dumpObj(data)
779 if (data["reply"] == "error")
780 {
781 thisClient.util.messageDialogue(data["error_message"])
782 ok = false
783 }
784 }
785 }
786 )
787
788 return ok
789 }
790
791 Client.prototype.majMenu = function()
792 {
793 // TODO : à virer : ne plus changer de style de display ... spa beau .. ou trouver une autre méthode
794 // var displayType = this.css == "css/3/euphorik.css" ? "block" : "inline" //this.client
795 displayType = "block"
796
797 $("#menu .admin").css("display", this.ekMaster ? displayType : "none")
798
799 // met à jour le menu
800 if (this.statut == statutType.auth_registered)
801 {
802 $("#menu .profile").css("display", displayType).text("profile")
803 $("#menu .logout").css("display", displayType)
804 $("#menu .register").css("display", "none")
805 }
806 else if (this.statut == statutType.auth_not_registered)
807 {
808 $("#menu .profile").css("display", "none")
809 $("#menu .logout").css("display", displayType)
810 $("#menu .register").css("display", displayType)
811 }
812 else
813 {
814 $("#menu .profile").css("display", displayType).text("login")
815 $("#menu .logout").css("display", "none")
816 $("#menu .register").css("display", displayType)
817 }
818 }
819
820 Client.prototype.slap = function(userId, raison)
821 {
822 var thisClient = this
823
824 jQuery.ajax({
825 type: "POST",
826 url: "request",
827 dataType: "json",
828 data: this.util.jsonVersAction(
829 {
830 "action" : "slap",
831 "cookie" : thisClient.cookie,
832 "user_id" : userId,
833 "reason" : raison
834 }),
835 success:
836 function(data)
837 {
838 if (data["reply"] == "error")
839 thisClient.util.messageDialogue(data["error_message"])
840 }
841 })
842 }
843
844 Client.prototype.ban = function(userId, raison, minutes)
845 {
846 var thisClient = this
847
848 // par défaut un ban correspond à 3 jours
849 if (typeof(minutes) == "undefined")
850 minutes = 60 * 24 * 3
851
852 jQuery.ajax({
853 type: "POST",
854 url: "request",
855 dataType: "json",
856 data: this.util.jsonVersAction(
857 {
858 "action" : "ban",
859 "cookie" : thisClient.cookie,
860 "duration" : minutes,
861 "user_id" : userId,
862 "reason" : raison
863 }),
864 success:
865 function(data)
866 {
867 if (data["reply"] == "error")
868 thisClient.util.messageDialogue(data["error_message"])
869 }
870 })
871 }
872
873 Client.prototype.kick = function(userId, raison)
874 {
875 this.ban(userId, raison, 15)
876 }
877
878 ///////////////////////////////////////////////////////////////////////////////////////////////////
879
880 /**
881 * classe permettant de gérer les événements (push serveur).
882 * @page la page
883 */
884 function PageEvent(page, util)
885 {
886 this.page = page
887 this.util = util
888
889 // l'objet JSONHttpRequest représentant la connexion d'attente
890 this.attenteCourante = null
891 }
892
893 /**
894 * Arrête l'attente courante s'il y en a une.
895 */
896 PageEvent.prototype.stopAttenteCourante = function()
897 {
898 if (this.attenteCourante != null)
899 this.attenteCourante.abort()
900 }
901
902 /**
903 * Attend un événement lié à la page.
904 * @funSend une fonction renvoyant les données json à envoyer
905 * @funReceive une fonction qui accepte un paramètre correspondant au données reçues
906 */
907 PageEvent.prototype.waitEvent = function(funSend, funReceive)
908 {
909 var thisPageEvent = this
910
911 this.stopAttenteCourante()
912
913 // on doit conserver l'ordre des valeurs de l'objet JSON (le serveur les veux dans l'ordre définit dans le protocole)
914 // TODO : ya pas mieux ?
915 var dataToSend =
916 {
917 "action" : "wait_event",
918 "page" : this.page
919 }
920 var poulpe = funSend()
921 for (v in poulpe)
922 dataToSend[v] = poulpe[v]
923
924 ;;; dumpObj(dataToSend)
925 this.attenteCourante = jQuery.ajax({
926 type: "POST",
927 url: "request",
928 dataType: "json",
929 data: this.util.jsonVersAction(dataToSend),
930 success:
931 function(data)
932 {
933 ;;; dumpObj(data)
934
935 funReceive(data)
936
937 // rappel de la fonction dans 100 ms
938 setTimeout(function(){ thisPageEvent.waitEvent(funSend, funReceive) }, 100);
939 },
940 error:
941 function(XMLHttpRequest, textStatus, errorThrown)
942 {
943 setTimeout(function(){ thisPageEvent.waitEvent(funSend, funReceive) }, 1000);
944 }
945 })
946
947 }
948
949 ///////////////////////////////////////////////////////////////////////////////////////////////////
950
951 function initialiserListeStyles(client)
952 {
953 $("#menuCss").change(
954 function()
955 {
956 client.setCss("css/" + $("option:selected", this).attr("value") + "/euphorik.css")
957 }
958 )
959 }
960
961 // charge dynamiquement le script de debug
962 ;;; jQuery.ajax({async : false, url : "js/debug.js", dataType : "script"})
963
964 // le main
965 $(document).ready(
966 function()
967 {
968 var formateur = new Formateur()
969 var util = new Util(formateur)
970 var client = new Client(util)
971 var pages = new Pages()
972
973 // connexion vers le serveur (utilise un cookie qui traine)
974 client.connexionCookie()
975
976 initialiserListeStyles(client)
977
978 // FIXME : ne fonctionne pas sous opera
979 // voir : http://dev.jquery.com/ticket/2892#preview
980 $(window).unload(function(){client.flush()})
981
982 $("#menu .minichat").click(function(){ pages.afficherPage("minichat") })
983 $("#menu .admin").click(function(){ pages.afficherPage("admin") })
984 $("#menu .profile").click(function(){ pages.afficherPage("profile") })
985 $("#menu .logout").click(function(){
986 util.messageDialogue("Êtes-vous sur de vouloir vous délogger ?", messageType.question,
987 {"Oui" : function()
988 {
989 client.deconnexion();
990 pages.afficherPage("minichat", true)
991 },
992 "Non" : function(){}
993 }
994 )
995 })
996 $("#menu .register").click(function(){ pages.afficherPage("register") })
997 $("#menu .about").click(function(){ pages.afficherPage("about") })
998
999 pages.ajouterPage(new PageMinichat(client, formateur, util))
1000 pages.ajouterPage(new PageAdmin(client, formateur, util))
1001 pages.ajouterPage(new PageProfile(client, formateur, util))
1002 pages.ajouterPage(new PageRegister(client, formateur, util))
1003 pages.ajouterPage(new PageAbout(client, formateur, util))
1004 pages.afficherPage("minichat")
1005 }
1006 )