1 //!-- UTF8 2 /* 3 Oregano Multiuser Server - Version 1.2.0 - January 4th, 2005 4 5 Web: www.oregano-server.org 6 Mail: info@oregano-server.org 7 8 Copyright 2003 - 2004 - 2004 Jens Halm / Cologne, Germany 9 10 This library is free software; you can redistribute it and/or 11 modify it under the terms of the GNU Lesser General Public 12 License as published by the Free Software Foundation; either 13 version 2.1 of the License, or (at your option) any later version. 14 15 This library is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 18 Lesser General Public License for more details. 19 20 You should have received a copy of the GNU Lesser General Public 21 License along with this library; if not, write to the Free Software 22 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 23 */ 24 25 /* 26 ------------------------------------------- 27 Classe User 28 29 @description : 30 Représentation d'un utilisateur enregistré et connecté. 31 Singleton 32 33 34 @author Jens Halm copyright http://www.spicefactory.org/ 35 @author erixtekila copyleft http://www.v-i-a.net 36 ------------------------------------------- 37 version history : 38 1.2.0 : 08/02/05 39 - Portage en actionscript 2 pour le 40 compile time type checking 41 - Implémentation du modèle Singleton 42 (abstraite auparavant) 43 - Rajout de la méthode init pour éviter une mauvaise instanciation 44 ------------------------------------------- 45 */ 46 47 import org.omus.util.EventDispatcher; 48 import org.omus.util.iObservable; 49 import org.omus.util._Error; 50 import org.omus.util._Class; 51 52 import org.omus.msg.MessageHandler; 53 import org.omus.msg.iMessageHandler; 54 import org.omus.msg.Mailbox; 55 import org.omus.msg.Message; 56 import org.omus.msg.Envelope; 57 import org.omus.msg.EnvelopeFactory; 58 59 import org.omus.core.Buddies; 60 import org.omus.core.Session; 61 import org.omus.core.Locks; 62 63 import org.omus.data.PropertySet; 64 65 /** 66 * Cette classe gère l'utilisateur sur son poste client. 67 * <p> 68 * Evénements auxquels s'abonner : 69 * <ul> 70 * <li>onSetEmail Généré lorsqu'un nouveau email est enregistré côté serveur. 71 * </li><li>onSetPassword Généré lorsqu'un nouveau mot de passe est enregistré côté serveur. 72 * </li><li>onSetPermissions Généré lorsque de nouvelles permissions sont enregistrées côté serveur. 73 * </li><li>onError(error:_Error) Généré en cas d'erreur à cause d'une mauvaise modification de propriété persistante. 74 * </li></ul></p> 75 * Cette classe est implémentée en suivant le modèle Singleton. 76 * Un accès global à son instance est obtenu graçe à la méthode getInstance. 77 * Elle est aggrémentée par composition des méthodes des sources d'événements (EventDispatcher). 78 * Elle est aggrémentée par composition de la classe MessageHandler. 79 * @see org.omus.util.EventDispatcher 80 * @see org.omus.util.iObservable 81 * @see org.omus.msg.MessageHandler 82 * @see org.omus.msg.iMessageHandler 83 * 84 * @author Jens Halm copyright http://www.spicefactory.org/ 85 * @author erixtekila copyleft http://www.v-i-a.net 86 * @version 1.2.0 87 */ 88 class org.omus.core.User implements iObservable, iMessageHandler 89 { 90 //-------------------- 91 // PROPRIETES 92 //-------------------- 93 /** 94 * Nom de l'utilisateur. 95 */ 96 private var name:String; 97 98 /** 99 * Mot de passe. 100 */ 101 private var password:String; 102 103 /** 104 * Nom de la boîte email interne. 105 */ 106 private var email:String; 107 108 /** 109 * Permissions affectées à l'utilisateur. 110 * 0 : Utilisateur supprimé. 111 * 1 : Utilisateur banni. 112 * 2-8 : Utilisateur avec status standard 113 * (Laissé pour les besoins de l'application) 114 * 3 : Nouvel utilisateur. 115 * 9-10 : Utilisateur avec status d'administrateur. 116 */ 117 private var permissions:Number; 118 119 /** 120 * Un objet contenant les propriétés utilisateur persistantes. 121 */ 122 public var propConfig:Object; 123 124 /** 125 * Valeur des propriétés persistantes. 126 */ 127 public var props:PropertySet; 128 129 /** 130 * Boîte des messages entrants. 131 */ 132 private var inBox:Mailbox; 133 134 /** 135 * Boîte des messages sortants. 136 */ 137 private var outBox:Mailbox; 138 139 /** 140 * Liste des copains, poteaux, aminches et les autres… 141 */ 142 private var buddies:Buddies; 143 144 /** 145 * Black-list des utilisateurs non souhaités. 146 */ 147 private var blackList:Buddies; 148 149 /** 150 * Verrous au sein d'un groupe. 151 */ 152 private var locks:Locks; 153 154 155 /** 156 * Référence au système de génération d'événements. 157 */ 158 private var _eventSource:EventDispatcher; 159 160 /** 161 * Référence à la classe MessageHandler; 162 */ 163 private var _messageHandler:MessageHandler; 164 165 /** 166 * Référence à l'unique instance de la classe permise. 167 */ 168 private static var _instance:User; 169 170 //-------------------- 171 // CONSTRUCTEUR 172 //-------------------- 173 /** 174 * L'objet User dispose des méthodes d'EventDispatcher 175 * et de celles de MessageHandler par composition. 176 * 177 * @see org.omus.util.EventDispatcher 178 * @see org.omus.util.iObservable 179 * @see org.omus.msg.MessageHandler 180 * @see org.omus.msg.iMessageHandler 181 */ 182 private function User() 183 { 184 // Composition avec EventDispatcher 185 _eventSource = new EventDispatcher(); 186 // Composition avec MessageHandler 187 _messageHandler = new MessageHandler(); 188 189 // Initialisation des événements 190 _messageHandler.initMessageHandler(this); 191 192 193 // Callbacks des envois de messages. 194 addHandler("setPassword","handleSetPassword"); 195 addHandler("setEmail","handleSetEmail"); 196 addHandler("setPerm","handleSetPermissions"); 197 198 // trace(this+ " installé."); 199 } 200 201 //-------------------- 202 // METHODES PUBLIQUES 203 //-------------------- 204 /** 205 * Utilisé dans un contexte littéral 206 * @return Une chaine définissant l'objet 207 */ 208 public function toString():String 209 { 210 var s = "[Objet User]"; 211 s += "\norg.omus.user:"; 212 s += "\nname = " + name; 213 s += "\npassword = " + password; 214 s += "\nemail = " + email; 215 s += "\npermissions = " + permissions; 216 return s; 217 } 218 219 /** 220 * Initialisation. 221 * 222 * @param regInfo Informations du compte utilisateur enregistré dans la base de données. 223 * @param loginInfo Préférences utilisateur : Mail, Buddy list… 224 * @param props Valeurs des propriétés persistantes définies. 225 * @param propConfig Propriétés persistantes. 226 */ 227 private function init(regInfo:Object, loginInfo:Object, props:Object, propConfig:Object):Void 228 { 229 // Propriétés 230 name = regInfo.username; 231 password = regInfo.pwd; 232 email = regInfo.email; 233 permissions = regInfo.permissions; 234 this.propConfig = propConfig; 235 236 // Mail box 237 inBox = new Mailbox("in"); 238 outBox = new Mailbox("out"); 239 inBox.init(loginInfo.inBoxTotal, loginInfo.inBoxUnread); 240 outBox.init(loginInfo.outBoxTotal, loginInfo.outBoxUnread); 241 242 // Buddy list 243 buddies = new Buddies("buddies", loginInfo.buddyCount, loginInfo.buddyLimit); 244 blackList = new Buddies("blackList", loginInfo.blackListCount, loginInfo.blackListLimit); 245 // Verrous 246 locks = new Locks(); 247 248 // Propriétés persistantes. 249 var ps = new PropertySet("user", name, regInfo.usrID, null); 250 ps.fill(propConfig, props); 251 this.props = ps; 252 } 253 254 /** 255 * Renvoie le nom utilisateur. 256 * 257 * @return Le nom utilisateur. 258 */ 259 public function getName ():String 260 { 261 return name; 262 } 263 264 /** 265 * Renvoie le mot de passe utilisateur. 266 * 267 * @return Le mot de passe. 268 */ 269 public function getPassword ():String 270 { 271 return password; 272 } 273 274 /** 275 * Renvoie l'email interne. 276 * 277 * @return Le nom d'email. 278 */ 279 public function getEmail ():String 280 { 281 return email; 282 } 283 284 /** 285 * Renvoie le niveau de permission de l'utilisateur. 286 * 287 * @return Le niveau de permission 288 * 0 : Utilisateur supprimé. 289 * 1 : Utilisateur banni. 290 * 2-8 : Utilisateur avec status standard 291 * (Laissé pour les besoins de l'application) 292 * 3 : Nouvel utilisateur. 293 * 9-10 : Utilisateur avec status d'administrateur. 294 */ 295 public function getPermissions ():Number 296 { 297 return permissions; 298 } 299 300 /** 301 * Définit le mot de passe. 302 * 303 * @param pwd Le nouveau mot de passe. 304 */ 305 public function setPassword (pwd:String):Void 306 { 307 // TODO : Accès Singleton 308 var clazz = _Class.getInstance(); 309 if (! clazz.checkArguments("org.omus.user.setPassword", [[pwd, "string", true]])) return; 310 setRegInfo("password", "Password", pwd); 311 } 312 313 /** 314 * Définit l'email interne. 315 * 316 * @param newAddr La nouvelle adresse email. 317 */ 318 public function setEmail (newAddr:String):Void 319 { 320 // TODO : Accès Singleton 321 var clazz = _Class.getInstance(); 322 if (! clazz.checkArguments("org.omus.user.setEmail", [[newAddr, "string", true]])) return; 323 setRegInfo("email","Email", newAddr); 324 } 325 326 /** 327 * Définit de nouvelles permissions. 328 * Génère un événement onError aux observateurs. 329 * 330 * @param perms Numéro d'identifiant de la nouvelle permission. 331 */ 332 public function setPermissions (perms:Number):Void 333 { 334 // TODO : Accès Singleton 335 var clazz = _Class.getInstance(); 336 if (! clazz.checkArguments("org.omus.user.setPermissions", [[perms, "number", true]])) return; 337 338 //!! TODO : Syntaxe. parseInt(String). var perm = parseInt(perms); 339 var perm = Number(perms); 340 if (isNaN(perm) || perm < 2 || perm > 10) 341 { 342 // Broadcast 343 fireEvent("error", "onError", new _Error("usr-004","setPermissions",arguments)); 344 return; 345 } 346 setRegInfo("permissions", "Perm", perm); 347 } 348 349 /** 350 * Renvoie l'objet des propriétés persistantes. 351 * 352 * @return Une référence vers toutes les propriétés persistantes de l'utilisateur. 353 */ 354 public function getProperties ():PropertySet 355 { 356 return props; 357 } 358 359 /** 360 * Renvoie une référence à la boite de messages entrants. 361 * 362 * @return Une référence à l'Inbox. 363 */ 364 public function getInBox ():Mailbox 365 { 366 return inBox; 367 } 368 369 /** 370 * Renvoie une référence à la boite de messages sortants. 371 * 372 * @return Une référence à l'Inbox. 373 */ 374 public function getOutBox ():Mailbox 375 { 376 return outBox; 377 } 378 379 /** 380 * Renvoie une référence à la listes des aminches. 381 * 382 * @return Une référence à la Buddy list. 383 */ 384 public function getBuddies ():Buddies 385 { 386 return buddies; 387 } 388 389 /** 390 * Renvoie une référence à liste des personnes inopportunes. 391 * 392 * @return Une référence à la Blacklist. 393 */ 394 public function getBlackList ():Buddies 395 { 396 return blackList; 397 } 398 399 /** 400 * Renvoie une référence au verrous posés par l'utuilisateur. 401 * 402 * @return Une référence aux verrous posés dans un groupe par l'utilisateur. 403 */ 404 public function getLocks ():Locks 405 { 406 return locks; 407 } 408 409 //*** Implémentation de iObservable ***\\ 410 /** 411 * Notifie les observateurs d'un événement. 412 * 413 * @param logLevel Une chaine caractérisant le niveau de logging de l'information. 414 * @param eventName Nom de l'événement. 415 * @param arg1 [option] Autant de paramêtres de voulu. 416 */ 417 private function fireEvent (logLevel:String, eventName:String):Void 418 { 419 _eventSource.fireEvent.apply (_eventSource, arguments); 420 } 421 422 /** 423 * Ajoute un nouvel observateur. 424 * 425 * @param listener Référence de l'observateur. 426 * @return Un booléen indiquant la réussite de l'opération. 427 */ 428 public function addListener (listener:Object):Boolean 429 { 430 return _eventSource.addListener(listener); 431 } 432 433 /** 434 * Supprime un observateur. 435 * 436 * @param listener Référence de l'observateur. 437 * @return Un booléen indiquant la réussite de l'opération. 438 */ 439 public function removeListener (listener:Object):Boolean 440 { 441 return _eventSource.removeListener(listener); 442 } 443 444 /** 445 * Supprime tous les abonnés. 446 */ 447 public function removeAllListeners ():Void 448 { 449 _eventSource.removeAllListeners(); 450 } 451 452 /** 453 * Retourne le nombre d'observateurs. 454 * 455 * @return Le nombre d'observateurs enregistrés. 456 */ 457 public function countListeners ():Number 458 { 459 return _eventSource.countListeners(); 460 } 461 462 //*** Implémentation de iMessageHandler ***\\ 463 /** 464 * Active la gestion d'un type de message par accusé de réception 465 * en fonction du contenu de son enveloppe. 466 * 467 * @param env Une référence à l'enveloppe. 468 */ 469 public function handleMessage (env:Envelope):Void 470 { 471 _messageHandler.handleMessage(env); 472 } 473 474 /** 475 * Rajoute un gestionnaire chargé d'intercepter 476 * la réponse du serveur suite à un message soumis. 477 * Forme d'accusé de réception (callback). 478 * 479 * @param subject Le type de message. 480 * @param methodName Le nom de l'événement gérant un type de message. 481 */ 482 public function addHandler (subject:String, methodName:String):Void 483 { 484 _messageHandler.addHandler (subject, methodName); 485 } 486 487 //*** Gestionnaire des accusés de réception de Message ***\\ 488 /** 489 * Gestionnaire de l'accusé de réception du message de changement de mot de passe. 490 * 491 * @param env Enveloppe. 492 */ 493 private function handleSetPassword (env:Envelope):Void 494 { 495 handleSetRegInfo(env, "password", "Password"); 496 } 497 498 /** 499 * Gestionnaire de l'accusé de réception du message de changement d'email. 500 * 501 * @param env Enveloppe. 502 */ 503 private function handleSetEmail (env:Envelope):Void 504 { 505 handleSetRegInfo(env, "email", "Email"); 506 } 507 508 /** 509 * Gestionnaire de l'accusé de réception de message de changement de permissions. 510 * 511 * @param env Enveloppe. 512 */ 513 private function handleSetPermissions (env:Envelope):Void 514 { 515 handleSetRegInfo(env, "permissions", "Permissions"); 516 } 517 518 /** 519 * Gestionnaire de réponse du message général pour d'une propriété d'enregistrement modifiée. 520 * Génère un événement onSetEmail, onSetPassword, onSetPermissions ou onError aux observateurs. 521 * 522 * @param env Enveloppe. 523 * @param lowerCase Nom de la propriété à modifier. 524 * @param upperCase Nom de la propriété à modifier abrégée et commançant par une majuscule. 525 */ 526 private function handleSetRegInfo (env:Envelope, lowerCase:String, upperCase:String):Void 527 { 528 var attach = env.getMessage().getAttachment(); 529 var errCode = attach.error; 530 if (errCode == "ok") { 531 this[lowerCase] = attach[lowerCase]; 532 // Broadcast 533 fireEvent("info", "onSet" + upperCase); 534 } else { 535 // Broadcast 536 fireEvent("error","onError", new _Error(errCode, "set" + upperCase,[attach[lowerCase]])); 537 } 538 } 539 // Fin des callbacks de Message 540 541 //-------------------- 542 // METHODES PRIVEES 543 //-------------------- 544 /** 545 * Définit de nouvelles propriétés pour la sauvegarde 546 * des caractéristiques de l'utilisateur côté serveur. 547 * 548 * @param lowerCase Nom de la propriété à modifier. 549 * @param upperCase Nom de la propriété à modifier abrégée et commançant par une majuscule. 550 * @param value Valeur de la nouvelle p 551 */ 552 private function setRegInfo (lowerCase:String, upperCase:String, value:Object) { 553 var msg = new Message("set" + upperCase); 554 var attach = msg.getAttachment(); 555 attach[lowerCase] = value; 556 557 // Crée une enveloppe pour le message 558 // TODO : Accès Singleton 559 var envFactory = EnvelopeFactory.getInstance(); 560 var env = envFactory.getOutgoing(msg, "set" + upperCase); 561 // TODO : Accès Singleton 562 var session = Session.getInstance(); 563 session.sendMessage(env); 564 } 565 566 /** 567 * Retourne la référence au conteneur de propriétés persistantes. 568 * 569 * @return Une référence aux propriétés persistantes. 570 */ 571 private function getPropConfig ():Object 572 { 573 return propConfig; 574 } 575 576 //-------------------- 577 // METHODES STATIQUES 578 //-------------------- 579 /** 580 * Utilisé dans un contexte littéral 581 * 582 * @return Une chaine définissant l'objet. 583 */ 584 public static function toLog():String 585 { 586 return "[Objet User]"; 587 } 588 589 /** 590 * Accès global à la référence du Singleton 591 * 592 * @return Une référence à la classe 593 */ 594 public static function getInstance():User 595 { 596 if(_instance == undefined) _instance = new User(); 597 return _instance; 598 } 599 } 600