Package spade :: Module Unit
[hide private]
[frames] | no frames]

Source Code for Module spade.Unit

   1  # -*- coding: UTF8 -*- 
   2  import random 
   3  import string 
   4   
   5  from xmpp import * 
   6  from Queue import * 
   7  import Behaviour 
   8   
9 -class CreationError(Exception):
10 - def __init__(self):
11 Exception.__init__(self)
12 -class NotValidName(CreationError):
13 - def __init__(self):
15 -class NotValidGoalChange(Exception):
16 - def __init__(self):
17 Exception.__init__(self)
18 -class NotValidType(CreationError):
19 - def __init__(self):
21 -class NotValidGoal(CreationError):
22 - def __init__(self):
24 -class NotAdmin(CreationError):
25 - def __init__(self):
27 -class NotSupervisor(CreationError):
28 - def __init__(self):
30 -class JoinError(Exception):
31 - def __init__(self):
32 Exception.__init__(self)
33 -class PaswordNeeded(JoinError):
34 - def __init__(self):
35 JoinError.__init__(self)
36 -class MembersOnly(JoinError):
37 - def __init__(self):
38 JoinError.__init__(self)
39 -class BanedUser(JoinError):
40 - def __init__(self):
41 JoinError.__init__(self)
42 -class NickNameConflict(JoinError):
43 - def __init__(self):
44 JoinError.__init__(self)
45 -class MaximumUsers(JoinError):
46 - def __init__(self):
47 JoinError.__init__(self)
48 -class LockedUnit(JoinError):
49 - def __init__(self):
50 JoinError.__init__(self)
51 -class Unavailable(Exception):
52 - def __init__(self):
53 Exception.__init__(self)
54 -class DestroyError(Exception):
55 - def __init__(self):
56 Exception.__init__(self)
57 -class NotValidUnit(Exception):
58 - def __init__(self):
59 Exception.__init__(self)
60 -class LastOwner(Exception):
61 - def __init__(self):
62 Exception.__init__(self)
63 -class Unit(Behaviour.OneShotBehaviour):
64
65 - def __init__(self,agent, nick, name, type="Team", goalList=[], agentList=[], contentLanguage="sl",password=None,create=True):
66 Behaviour.OneShotBehaviour.__init__(self) 67 self.myAgent=agent 68 self.name = name 69 self.type = type 70 self.goalList = goalList 71 self.agentList = agentList 72 self.contentLanguage = contentLanguage 73 self.platform = self.myAgent.getSpadePlatformJID() 74 self.muc_name = self.myAgent.getMUC() 75 self._roster = {} 76 self.nick=nick 77 self.password=password 78 self.create=create 79 self.parent_type=None 80 self.parent=None 81 id_base = "".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) #@UnusedVariable 82 self.ID = str(name) + str(self.myAgent.getAID().getName()) + id_base 83 self.state="unavailable" 84 self.UnavailableMsg="Unit" 85 self.members=[] 86 self.owner_admin=False
87 88
89 - def setup(self):
90 pass
91 92 93 94 95
96 - def myCreate(self):
97 if not self.checkGoal(self.goalList): 98 raise NotValidGoal 99 elif not self.checkType(): 100 raise NotValidType 101 elif self.type=="Hierarchy" and self.password==None: 102 raise PaswordNeeded 103 elif not self.testRoomName(): 104 raise NotValidName 105 elif not self.createRoom(): 106 raise CreationError 107 else: 108 self.state="available" 109 if self.agentList!=[]: 110 #enviando invitaciones 111 self.invite(self.agentList) 112 #registrando en el DF 113 #dad = DF.DfAgentDescription() 114 #ds = DF.ServiceDescription() 115 #ds.setType("Unit: "+self.parent) 116 #ds.setName(self.name) 117 #dad.addService(ds) 118 # res = self.myAgent.registerService(dad) 119 #anyadimos el comportamiento que lee los presence 120 self.owner_admin=True 121 p = Presence() 122 t = Behaviour.MessageTemplate(p) 123 self.presenceBehaviour=self.PresenceBehaviour(self.muc_name,self.name,self.nick,self) 124 self.myAgent.addBehaviour(self.presenceBehaviour, t)
125
126 - def myJoin(self):
127 #The Organization exists 128 if not self.testUnitName(): 129 raise NotValidName 130 #The room no existe 131 elif not self.myJoinRoom(): 132 raise JoinError 133 #No es una organizacion 134 else: 135 info=self.getInfo() 136 if info: 137 self.type = info["type"] 138 self.contentLanguage = info["contentLanguage"] 139 self.parent=info["parent"] 140 parent_info=self.myAgent.getOrganizationInfo(self.parent) 141 self.parent_type=parent_info["type"] 142 self.goal=info["goal"] 143 self.state="available" 144 p = Presence() 145 t = Behaviour.MessageTemplate(p) 146 self.presenceBehaviour=self.PresenceBehaviour(self.muc_name,self.name,self.nick,self) 147 self.myAgent.addBehaviour(self.presenceBehaviour, t)
148 149 150 151
152 - def testRoomName(self):
153 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 154 iq = Iq(frm=self.muc_name, attrs={"id":ID}) 155 t = Behaviour.MessageTemplate(iq) 156 b=self.TestRoomNameBehaviour(ID,self.muc_name,self.name) 157 self.myAgent.addBehaviour(b, t) 158 b.join() 159 return b.result
160 161 162 163 164
165 - class TestRoomNameBehaviour(Behaviour.OneShotBehaviour):
166 - def __init__(self,ID,muc_name,roomname):
167 Behaviour.OneShotBehaviour.__init__(self) 168 self.ID=ID 169 self.result = False 170 self.muc_name=muc_name 171 self.roomname=roomname
172
173 - def _process(self):
174 iq = Iq(to=self.muc_name,typ='get', attrs={"id":self.ID}) 175 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#items") 176 iq.addChild(node=query) 177 self.myAgent.jabber.send(iq) 178 msg = self._receive(True,10) 179 if msg: 180 if query: 181 self.result = True 182 items = msg.getQueryChildren() 183 for item in items: 184 if item.getAttr("jid") == str(self.roomname+"@"+self.muc_name): 185 self.result = False 186 else: 187 self.result = False
188 189
190 - def createRoom(self):
191 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 192 p = Presence(frm=self.name+"@"+self.muc_name+"/"+self.nick) 193 t1 = Behaviour.MessageTemplate(p) 194 b=self.CreateRoomBehaviour(ID,self.muc_name,self.name,self.nick,self.parent,self.contentLanguage,self.type,self.goalList,self.password,self.agentList) 195 self.myAgent.addBehaviour(b, t1) 196 b.join() 197 return b.result
198
199 - class CreateRoomBehaviour(Behaviour.OneShotBehaviour):
200 - def __init__(self,ID,muc_name,roomname,nick,parent,contentLanguage,type,goalList,password,agentList):
201 Behaviour.OneShotBehaviour.__init__(self) 202 self.result = False 203 self.ID=ID 204 self.nick=nick 205 self.muc_name=muc_name 206 self.name=roomname 207 self.parent=parent 208 self.contentLanguage=contentLanguage 209 self.type=type 210 self.goalList=goalList 211 self.password=password 212 self.agentList=agentList
213
214 - def _process(self):
215 p = Presence(to=self.name+"@"+self.muc_name+"/"+self.nick) 216 x = Protocol("x", xmlns="http://jabber.org/protocol/muc") 217 p.addChild(node=x) 218 self.myAgent.jabber.send(p) 219 msg=self._receive(True,10) 220 if msg: 221 if msg.getAttr("type")=="error": 222 print "Room creation is restricted" 223 self.result= False 224 return 225 else: 226 self.result= False 227 return 228 template= Iq(frm=self.name+"@"+self.muc_name, attrs={"id":self.ID}) 229 t = Behaviour.MessageTemplate(template) 230 self.setTemplate(t) 231 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 232 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 233 iq.addChild(node=query) 234 self.myAgent.jabber.send(iq) 235 236 msg = self._receive(True,10) 237 #para descartar los presence anteriores 238 while msg and msg.getName()!="iq": 239 msg = self._receive(True,10) 240 241 #setting room configuration 242 if not msg or msg.getAttr("type")=="error": 243 print "No configuration is possible: "+msg.getError() 244 #cambiar 245 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 246 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 247 x=Node(tag="x", attrs={"xmlns":"jabber:x:data"," type":"submit"}) 248 query.addChild(node=x) 249 iq.addChild(node=query) 250 self.myAgent.jabber.send(iq) 251 #return False 252 self.result= False 253 return 254 ispasswordprotected=False 255 if self.type=="Hierarchy" or self.password!=None: 256 ispasswordprotected=True 257 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 258 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 259 x=Node(tag="x", attrs={"xmlns":"jabber:x:data"," type":"submit"}) 260 resquery=msg.getQueryChildren()[0] #nos quedamos con el hijo de query 261 if resquery: items = resquery.getTags("field") 262 if resquery==None: 263 print "No configuration is possible" 264 return False 265 for item in items: 266 if item.getAttr("var"): 267 value=None 268 if item.getAttr("var") == "muc#roomconfig_lang": 269 value=self.contentLanguage 270 if item.getAttr("var") == "muc#roomconfig_roomdesc": 271 value=self.type 272 if item.getAttr("var") == "muc#roomconfig_roomname": 273 value=self.name 274 if item.getAttr("var") == "muc#roomconfig_roomtype": 275 value="Unit:"+self.parent 276 if item.getAttr("var") == "muc#roomconfig_presencebroadcast": 277 value="moderator" 278 if item.getAttr("var") == "muc#roomconfig_persistentroom": 279 value="1" 280 if item.getAttr("var") == "muc#roomconfig_publicroom": 281 value="1" 282 if item.getAttr("var") == "muc#roomconfig_moderatedroom": 283 value="1" 284 if item.getAttr("var") == "muc#roomconfig_passwordprotectedroom": 285 if self.type=="Hierarchy" or self.password!=None: 286 value="1" 287 else: 288 value="0" 289 if item.getAttr("var")=="muc#roomconfig_roomsecret": 290 value=self.password 291 if item.getAttr("var") == "muc#roomconfig_whois": 292 if self.type=="Hierarchy": 293 value="moderators" 294 else: 295 value="anyone" 296 if item.getAttr("var") == "muc#roomconfig_changeSubject": 297 value="0" 298 if item.getAttr("var") == "muc#roomconfig_membersonly": 299 if self.type=="Flat": 300 value="0" 301 else: 302 value="1" 303 node=Node(tag="field", attrs={"var":item.getAttr("var")}) 304 valnode=Node(tag="value") 305 valnode.addData(value) 306 node.addChild(node=valnode) 307 if(item.getAttr("var")!="muc#roomconfig_roomsecret" or ispasswordprotected) and value!=None: 308 x.addChild(node=node) 309 query.addChild(node=x) 310 iq.addChild(node=query) 311 self.myAgent.jabber.send(iq) 312 msg = self._receive(True,10) 313 if msg and msg.getAttr("type")=="result": #comprobar mejor el mensaje que se devuelve 314 315 m = Message(to=self.name+"@"+self.muc_name, typ="groupchat") 316 sub = Node(tag="subject") 317 sub.addData(str(self.goalList)) 318 m.addChild(node=sub) 319 self.myAgent.jabber.send(m) 320 #quitarlo luego 321 for agent in self.agentList: 322 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 323 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 324 item= Node(tag="item", attrs={"affiliation":"member","jid":agent}) 325 query.addChild(node=item) 326 iq.addChild(node=query) 327 self.myAgent.jabber.send(iq) 328 self.result= True 329 else: 330 return False
331
332 - def myJoinRoom(self):
333 p = Presence(frm=self.name+"@"+self.muc_name,attrs={"type":"error"}) 334 t1 = Behaviour.MessageTemplate(p) 335 b=self.MyJoinRoomBehaviour(self.muc_name,self.name,self.nick,self.password) 336 self.myAgent.addBehaviour(b, t1) 337 b.join() 338 return b.result
339
340 - class MyJoinRoomBehaviour(Behaviour.OneShotBehaviour):
341 - def __init__(self,muc_name,roomname,nick,password):
342 Behaviour.OneShotBehaviour.__init__(self) 343 self.result = False 344 self.nick=nick 345 self.muc_name=muc_name 346 self.name=roomname 347 self.password=password
348
349 - def _process(self):
350 p = Presence(to=self.name+"@"+self.muc_name+"/"+self.nick) 351 x = Node(tag="x", attrs={"xmlns":"http://jabber.org/protocol/muc"}) 352 if self.password!=None: 353 pas=Node(tag="password") 354 pas.addData(self.password) 355 x.addChild(node=pas) 356 p.addChild(node=x) 357 self.myAgent.jabber.send(p) 358 msg=self._receive(True,10) 359 if msg: 360 error=msg.getTag("error") 361 if error.getAttr("code")=="401": 362 raise PaswordNeeded 363 if error.getAttr("code")=="407": 364 raise MembersOnly 365 if error.getAttr("code")=="403": 366 raise BanedUser 367 if error.getAttr("code")=="409": 368 raise NickNameConflict 369 if error.getAttr("code")=="503": 370 raise MaximumNumber 371 if error.getAttr("code")=="404": 372 raise LockedUnit 373 self.result = False 374 return 375 self.result = True
376 377
378 - def checkGoal(self,goalList):
379 #falta por implementar 380 if goalList!=None: 381 return True 382 else: 383 return False
384 385
386 - def checkType(self):
387 types=("Flat","Team","Hierarchy") 388 if self.type in types: 389 return True 390 return False
391
392 - def testUnitName(self):
393 info=self.getInfo() 394 if info: 395 if info["parent"]!="Organization" and info["parent"]!="": 396 return True 397 return False
398
399 - def invite(self,agentList):
400 if self.state=="unavailable": 401 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 402 return 403 for agent in agentList: 404 message = Node(tag="message", attrs={"to":self.name+"@"+self.muc_name}) 405 x=Node(tag="x",attrs={"xmlns":"http://jabber.org/protocol/muc#user"}) 406 y=Node(tag="invite",attrs={"to":agent}) 407 r=Node(tag="reason") 408 r.addData("Inivitation to the Unit "+self.name) 409 y.addChild(node=r) 410 x.addChild(node=y) 411 message.addChild(node=x) 412 self.myAgent.jabber.send(message)
413
414 - def setGoal(self,goalList):
415 """ 416 Updates organization goals 417 """ 418 #comprobar que sea un objetivo valido 419 if self.state=="unavailable": 420 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 421 return 422 if not self.checkGoal(goalList): 423 raise NotValidGoal 424 return 425 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 426 p = Message(frm=self.name+"@"+self.muc_name, typ="error", attrs={"id":ID}) 427 t1 = Behaviour.MessageTemplate(p) 428 b=self.SetGoalBehaviour(self.muc_name,self.name,goalList,ID) 429 self.myAgent.addBehaviour(b, t1)
430 431 432
433 - class SetGoalBehaviour(Behaviour.OneShotBehaviour):
434 - def __init__(self,muc_name,roomname,goalList,ID):
435 Behaviour.OneShotBehaviour.__init__(self) 436 self.goalList=goalList 437 self.muc_name=muc_name 438 self.name=roomname 439 self.ID=ID
440
441 - def _process(self):
442 m = Message(to=self.name+"@"+self.muc_name, typ="groupchat",attrs={"id":self.ID}) 443 sub = Node(tag="subject") 444 sub.addData(str(self.goalList)) 445 m.addChild(node=sub) 446 self.myAgent.jabber.send(m) 447 msg=self._receive(True,10) 448 if msg: 449 raise NotValidGoalChange
450
451 - def getGoal(self):
452 """ 453 Retruns a list of goals 454 """ 455 if self.state=="unavailable": 456 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 457 return 458 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 459 p = Iq(frm=self.name+"@"+self.muc_name,typ='result', attrs={"id":ID}) 460 t1 = Behaviour.MessageTemplate(p) 461 b=self.GetGoalBehaviour(self.muc_name,self.name,ID) 462 self.myAgent.addBehaviour(b, t1) 463 b.join() 464 return b.result
465 466
467 - class GetGoalBehaviour(Behaviour.OneShotBehaviour):
468 - def __init__(self,muc_name,roomname,ID):
469 Behaviour.OneShotBehaviour.__init__(self) 470 self.ID=ID 471 self.muc_name=muc_name 472 self.name=roomname 473 self.result=None
474
475 - def _process(self):
476 goal=None 477 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 478 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 479 iq.addChild(node=query) 480 self.myAgent.jabber.send(iq) 481 msg=self._receive(True,10) 482 if msg: 483 query = msg.getTag("query") 484 if query: 485 x = query.getTag("x") 486 if x: 487 items =x.getChildren() 488 for item in items: 489 if item.getAttr("var")=="muc#roominfo_subject": 490 if item.getTags("value"): 491 goal=item.getTags("value")[0].getData() 492 if goal==None: 493 print "Not goal" 494 self.result=goal
495 496
497 - def getInfo(self):
498 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 499 p = Iq(frm=self.name+"@"+self.muc_name,typ='result', attrs={"id":ID}) 500 t1 = Behaviour.MessageTemplate(p) 501 b=self.GetInfoBehaviour(self.muc_name,self.name,ID) 502 self.myAgent.addBehaviour(b, t1) 503 b.join() 504 return b.result
505 506
507 - class GetInfoBehaviour(Behaviour.OneShotBehaviour):
508 - def __init__(self,muc_name,roomname,ID):
509 Behaviour.OneShotBehaviour.__init__(self) 510 self.ID=ID 511 self.muc_name=muc_name 512 self.name=roomname 513 self.result=None
514
515 - def _process(self):
516 info={} 517 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 518 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 519 iq.addChild(node=query) 520 self.myAgent.jabber.send(iq) 521 msg=self._receive(True,10) 522 if msg: 523 query = msg.getTag("query") 524 if query: 525 x = query.getTag("x") 526 if x: 527 items =x.getChildren() 528 for item in items: 529 if item.getAttr("var")=="muc#roominfo_description": 530 if item.getTags("value"): 531 info["type"]=item.getTags("value")[0].getData() 532 if item.getAttr("var")=="muc#roominfo_subject": 533 if item.getTags("value"): 534 info["goal"]=item.getTags("value")[0].getData() 535 if item.getAttr("var")=="muc#roominfo_type": 536 if item.getTags("value")[0].getData(): 537 if ':' in item.getTags("value")[0].getData(): 538 info["parent"]= item.getTags("value")[0].getData().split(':')[1] 539 else: 540 info["parent"]=item.getTags("value")[0].getData() 541 if item.getAttr("var")=="muc#roominfo_type": 542 if item.getTags("value"): 543 info["contentLanguage"]=item.getTags("value")[0].getData() 544 self.result=info
545 546
547 - def getMemberList(self):
548 """ 549 Returns a List with Agents' names belonging to the organization 550 """ 551 if self.state=="unavailable": 552 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 553 return 554 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 555 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 556 t1 = Behaviour.MessageTemplate(p) 557 b=self.GetMemberListBehaviour(self.muc_name,self.name,ID) 558 self.myAgent.addBehaviour(b, t1) 559 b.join() 560 return b.result
561
562 - class GetMemberListBehaviour(Behaviour.OneShotBehaviour):
563 - def __init__(self,muc_name,roomname,ID):
564 Behaviour.OneShotBehaviour.__init__(self) 565 self.ID=ID 566 self.muc_name=muc_name 567 self.name=roomname 568 self.result=[]
569
570 - def _process(self):
571 # si es una unidad tambien hay que mirar si el presence broadcast est√° restringido 572 # if not checkOwner(self.myAgent): 573 # print "This agent is not allowed to get the memberList" 574 agents=[] 575 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 576 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 577 item= Node(tag="item", attrs={"affiliation":"member"}) 578 query.addChild(node=item) 579 iq.addChild(node=query) 580 self.myAgent.jabber.send(iq) 581 msg=self._receive(True,10) 582 if msg: 583 error=msg.getError() 584 if error!=None: 585 print error 586 return 587 query = msg.getTag("query") 588 if query: 589 items =query.getChildren() 590 for item in items: 591 agents.append(str(item.getAttr("jid"))) 592 self.result=agents 593 return
594 595
596 - def getMaxAgents(self):
597 """ 598 Returns Maximum agents allowed to enter inside the Organization 599 """ 600 if self.state=="unavailable": 601 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 602 return 603 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 604 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 605 t1 = Behaviour.MessageTemplate(p) 606 b=self.GetMaxAgentsBehaviour(self.muc_name,self.name,ID) 607 self.myAgent.addBehaviour(b, t1) 608 b.join() 609 return b.result
610
611 - class GetMaxAgentsBehaviour(Behaviour.OneShotBehaviour):
612 - def __init__(self,muc_name,roomname,ID):
613 Behaviour.OneShotBehaviour.__init__(self) 614 self.ID=ID 615 self.muc_name=muc_name 616 self.name=roomname 617 self.result=None
618
619 - def _process(self):
620 621 maxAgents=None 622 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 623 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 624 iq.addChild(node=query) 625 self.myAgent.jabber.send(iq) 626 msg = self._receive(True,10) 627 if msg: 628 query = msg.getTag("query") 629 if query: 630 x = query.getTag("x") 631 items =x.getChildren() 632 for item in items: 633 if item.getAttr("var")=="muc#roominfo_maxusers": 634 maxAgents=item.getTags("value")[0].getData() 635 if maxAgents==None: 636 print "Maximum agents has not been established" 637 self.result=maxAgents
638 - def getMinAgents(self):
639 """ 640 Returns Minimum agents needed to allow conversations inside 641 """ 642 if self.state=="unavailable": 643 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 644 return 645 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 646 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 647 t1 = Behaviour.MessageTemplate(p) 648 b=self.GetMinAgentsBehaviour(self.muc_name,self.name,ID) 649 self.myAgent.addBehaviour(b, t1) 650 b.join() 651 return b.result
652
653 - class GetMinAgentsBehaviour(Behaviour.OneShotBehaviour):
654 - def __init__(self,muc_name,roomname,ID):
655 Behaviour.OneShotBehaviour.__init__(self) 656 self.ID=ID 657 self.muc_name=muc_name 658 self.name=roomname 659 self.result=None
660
661 - def _process(self):
662 minAgents=None 663 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 664 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 665 iq.addChild(node=query) 666 self.myAgent.jabber.send(iq) 667 msg = self._receive(True,10) 668 if msg: 669 query = msg.getTag("query") 670 if query: 671 x = query.getTag("x") 672 items =x.getChildren() 673 for item in items: 674 if item.getAttr("var")=="muc#roominfo_minusers": 675 minAgents=item.getTags("value")[0].getData() 676 if minAgents==None: 677 print "Minimum agents has not been established" 678 self.result= minAgents
679
680 - def setMaxAgents(self,maxUsers):
681 """ 682 Updates Maximum agents allowed to enter inside the Organization 683 """ 684 if self.state=="unavailable": 685 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 686 return 687 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 688 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 689 t1 = Behaviour.MessageTemplate(p) 690 b=self.SetMaxAgentsBehaviour(self.muc_name,self.name,ID,maxUsers) 691 self.myAgent.addBehaviour(b, t1) 692 b.join()
693
694 - class SetMaxAgentsBehaviour(Behaviour.OneShotBehaviour):
695 - def __init__(self,muc_name,roomname,ID,maxUsers):
696 Behaviour.OneShotBehaviour.__init__(self) 697 self.ID=ID 698 self.muc_name=muc_name 699 self.name=roomname 700 self.maxUsers=maxUsers
701
702 - def _process(self):
703 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 704 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 705 iq.addChild(node=query) 706 self.myAgent.jabber.send(iq) 707 msg = self._receive(True,10) 708 if msg.getAttr("type")!="result": 709 print "Forbidden. Not owner" #completar un poco el error 710 return 711 #setting room configuration 712 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 713 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 714 x=Node(tag="x", attrs={"xmlns":"jabber:x:data"," type":"submit"}) 715 print msg.getQueryChildren() 716 resquery=msg.getQueryChildren()[0] #nos quedamos con el hijo de query 717 if resquery: items = resquery.getTags("field") 718 if resquery==None: 719 print "No configuration is possible" 720 self.result= False 721 for item in items: 722 value=None 723 if item.getAttr("var"): 724 value=item.getAttr("value") #tomamos el valor 725 if item.getAttr("var") == "muc#roomconfig_maxusers": 726 value=self.maxUsers 727 if value: 728 node=Node(tag="field", attrs={"var":item.getAttr("var")}) 729 valnode=Node(tag="value") 730 valnode.addData(value) 731 node.addChild(node=valnode) 732 x.addChild(node=node) 733 query.addChild(node=x) 734 iq.addChild(node=query) 735 self.myAgent.jabber.send(iq)
736 737
738 - def setMinAgents(self,minUsers):
739 """ 740 Updates Minimum agents needed to allow conversations inside 741 """ 742 if self.state=="unavailable": 743 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 744 return 745 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 746 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 747 t1 = Behaviour.MessageTemplate(p) 748 b=self.SetMinAgentsBehaviour(self.muc_name,self.name,ID,minUsers) 749 self.myAgent.addBehaviour(b, t1) 750 b.join()
751
752 - class SetMinAgentsBehaviour(Behaviour.OneShotBehaviour):
753 - def __init__(self,muc_name,roomname,ID,minUsers):
754 Behaviour.OneShotBehaviour.__init__(self) 755 self.ID=ID 756 self.muc_name=muc_name 757 self.name=roomname 758 self.minUsers=minUsers
759
760 - def _process(self):
761 self.myAgent.register_mailbox(typ="iq",id=self.ID) 762 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 763 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 764 iq.addChild(node=query) 765 self.myAgent.jabber.send(iq) 766 msg = self._receive(True,10) 767 if msg.getAttr("type")!="result": 768 print "Forbidden. Not owner" #completar un poco el error 769 return 770 self.myAgent.register_mailbox(typ="iq",id=self.ID) 771 #setting room configuration 772 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 773 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 774 x=Node(tag="x", attrs={"xmlns":"jabber:x:data"," type":"submit"}) 775 print msg.getQueryChildren() 776 resquery=msg.getQueryChildren()[0] #nos quedamos con el hijo de query 777 if resquery: items = resquery.getTags("field") 778 if resquery==None: 779 print "No configuration is possible" 780 self.result= False 781 for item in items: 782 value=None 783 if item.getAttr("var"): 784 value=item.getAttr("value") #tomamos el valor 785 if item.getAttr("var") == "muc#roomconfig_minusers": 786 value=self.minUsers 787 if value: 788 node=Node(tag="field", attrs={"var":item.getAttr("var")}) 789 valnode=Node(tag="value") 790 valnode.addData(value) 791 node.addChild(node=valnode) 792 x.addChild(node=node) 793 query.addChild(node=x) 794 iq.addChild(node=query) 795 self.myAgent.jabber.send(iq)
796 797
798 - def getNumberOfAgents(self):
799 """ 800 Returns current number od agents that are inside 801 """ 802 if self.state=="unavailable": 803 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 804 return 805 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 806 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 807 t1 = Behaviour.MessageTemplate(p) 808 b=self.GetNumberOfAgentsBehaviour(self.muc_name,self.name,ID) 809 self.myAgent.addBehaviour(b, t1) 810 b.join() 811 return b.result
812
813 - class GetNumberOfAgentsBehaviour(Behaviour.OneShotBehaviour):
814 - def __init__(self,muc_name,roomname,ID):
815 Behaviour.OneShotBehaviour.__init__(self) 816 self.ID=ID 817 self.muc_name=muc_name 818 self.name=roomname 819 self.result=None
820
821 - def _process(self):
822 agents=None 823 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 824 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 825 iq.addChild(node=query) 826 self.myAgent.jabber.send(iq) 827 msg = self._receive(True,10) 828 if msg: 829 query = msg.getTag("query") 830 if query: 831 x = query.getTag("x") 832 if x: 833 items =x.getChildren() 834 for item in items: 835 if item.getAttr("var")=="muc#roominfo_occupants": 836 agents=item.getTags("value")[0].getData() 837 if agents==None: 838 print "Error" 839 self.result=agents
840 841
842 - def getOwnerList(self):
843 if self.state=="unavailable": 844 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 845 return 846 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 847 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 848 t = Behaviour.MessageTemplate(p) 849 b=self.GetOwnerListBehaviour(self.muc_name,self.name,ID) 850 self.myAgent.addBehaviour(b, t) 851 b.join() 852 return b.result
853
854 - class GetOwnerListBehaviour(Behaviour.OneShotBehaviour):
855 - def __init__(self,muc_name,roomname,ID):
856 Behaviour.OneShotBehaviour.__init__(self) 857 self.ID=ID 858 self.muc_name=muc_name 859 self.name=roomname 860 self.result=[]
861
862 - def _process(self):
863 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 864 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 865 item= Node(tag="item", attrs={"affiliation":"owner"}) 866 query.addChild(node=item) 867 iq.addChild(node=query) 868 self.myAgent.jabber.send(iq) 869 msg = self._receive(True,10) 870 if msg: 871 if msg.getAttr("type")!="result": 872 print msg.getError() #completar un poco el error 873 return 874 query = msg.getQueryChildren() 875 if query: 876 #items =query.getChildren() 877 owners=[] 878 for item in query: 879 if item.getAttr("jid"): 880 owners.append(str(item.getAttr("jid"))) 881 self.result=owners 882 return
883
884 - def addAdmin(self,newAdminJID):
885 if self.state=="unavailable": 886 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 887 return 888 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 889 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 890 t = Behaviour.MessageTemplate(p) 891 b=self.AddAdminBehaviour(self.muc_name,self.name,ID,newAdminJID) 892 self.myAgent.addBehaviour(b, t) 893 b.join()
894
895 - class AddAdminBehaviour(Behaviour.OneShotBehaviour):
896 - def __init__(self,muc_name,roomname,ID,newAdminJID):
897 Behaviour.OneShotBehaviour.__init__(self) 898 self.ID=ID 899 self.muc_name=muc_name 900 self.name=roomname 901 self.newAdminJID=newAdminJID 902 self.result=None
903
904 - def _process(self):
905 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 906 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 907 item= Node(tag="item", attrs={"affiliation":"admin","jid":self.newAdminJID}) 908 query.addChild(node=item) 909 iq.addChild(node=query) 910 self.myAgent.jabber.send(iq) 911 msg = self._receive(True,10) 912 if msg: 913 if msg.getAttr("type")=="error": 914 print msg.getError() #completar un poco el error
915 916
917 - def removeAdmin(self,AdminJID):
918 if self.state=="unavailable": 919 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 920 return 921 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 922 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 923 t = Behaviour.MessageTemplate(p) 924 b=self.RemoveAdminBehaviour(self.muc_name,self.name,ID,AdminJID) 925 self.myAgent.addBehaviour(b, t) 926 b.join() 927 return b.result
928
929 - class RemoveAdminBehaviour(Behaviour.OneShotBehaviour):
930 - def __init__(self,muc_name,roomname,ID,newAdminJID):
931 Behaviour.OneShotBehaviour.__init__(self) 932 self.ID=ID 933 self.muc_name=muc_name 934 self.name=roomname 935 self.newAdminJID=newAdminJID 936 self.result=None
937
938 - def _process(self):
939 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 940 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 941 item= Node(tag="item", attrs={"affiliation":"admin"}) 942 query.addChild(node=item) 943 iq.addChild(node=query) 944 self.myAgent.jabber.send(iq) 945 msg = self._receive(True,10) 946 exists=False 947 if msg: 948 if msg.getAttr("type")!="result": 949 print msg.getError() #completar un poco el error 950 return 951 query = msg.getQueryChildren() 952 if query: 953 iqAns = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 954 queryAns = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 955 for item in query: 956 if str(item.getAttr("jid"))==self.newAdminJID: 957 i=Node(tag="item",attrs={"affiliation":"member","jid":self.newAdminJID}) 958 queryAns.addChild(node=item) 959 960 iqAns.addChild(node=queryAns) 961 self.myAgent.jabber.send(iqAns) 962 msgAns = self._receive(True,10) 963 if msgAns: 964 if msgAns.getAttr("type")!="result": 965 print msgAns.getError() #completar un poco el error 966 else: 967 exists=True 968 if not exists: 969 print "The JID "+self.newAdminJID+" doesn't belong to a admin" 970 return 971 print "Error"#completar un poco el error
972
973 - def getAdminList(self):
974 if self.state=="unavailable": 975 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 976 return 977 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 978 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 979 t = Behaviour.MessageTemplate(p) 980 b=self.GetAdminListBehaviour(self.muc_name,self.name,ID) 981 self.myAgent.addBehaviour(b, t) 982 b.join() 983 return b.result
984
985 - class GetAdminListBehaviour(Behaviour.OneShotBehaviour):
986 - def __init__(self,muc_name,roomname,ID):
987 Behaviour.OneShotBehaviour.__init__(self) 988 self.ID=ID 989 self.muc_name=muc_name 990 self.name=roomname 991 self.result=[]
992
993 - def _process(self):
994 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 995 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 996 item= Node(tag="item", attrs={"affiliation":"admin"}) 997 query.addChild(node=item) 998 iq.addChild(node=query) 999 self.myAgent.jabber.send(iq) 1000 msg = self._receive(True,10) 1001 if msg: 1002 if msg.getAttr("type")!="result": 1003 print msg.getError() #completar un poco el error 1004 return 1005 query = msg.getQueryChildren() 1006 if query: 1007 #items =query.getChildren() 1008 owners=[] 1009 for item in query: 1010 if item.getAttr("jid"): 1011 owners.append(str(item.getAttr("jid"))) 1012 self.result=owners 1013 return
1014
1015 - def addOwner(self,newOwnerJID):
1016 if self.state=="unavailable": 1017 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1018 return 1019 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1020 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1021 t = Behaviour.MessageTemplate(p) 1022 b=self.AddOwnerBehaviour(self.muc_name,self.name,ID,newOwnerJID) 1023 self.myAgent.addBehaviour(b, t) 1024 b.join()
1025
1026 - class AddOwnerBehaviour(Behaviour.OneShotBehaviour):
1027 - def __init__(self,muc_name,roomname,ID,newOwnerJID):
1028 Behaviour.OneShotBehaviour.__init__(self) 1029 self.ID=ID 1030 self.muc_name=muc_name 1031 self.name=roomname 1032 self.newOwnerJID=newOwnerJID 1033 self.result=None
1034
1035 - def _process(self):
1036 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1037 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1038 item= Node(tag="item", attrs={"affiliation":"owner","jid":self.newOwnerJID}) 1039 query.addChild(node=item) 1040 iq.addChild(node=query) 1041 self.myAgent.jabber.send(iq) 1042 msg = self._receive(True,10) 1043 if msg: 1044 if msg.getAttr("type")!="result": 1045 print msg.getError() #completar un poco el error
1046 1047
1048 - def removeOwner(self,OwnerJID):
1049 if self.state=="unavailable": 1050 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1051 return 1052 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1053 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1054 t = Behaviour.MessageTemplate(p) 1055 b=self.RemoveOwnerBehaviour(self.muc_name,self.name,ID,OwnerJID) 1056 self.myAgent.addBehaviour(b, t) 1057 b.join()
1058
1059 - class RemoveOwnerBehaviour(Behaviour.OneShotBehaviour):
1060 - def __init__(self,muc_name,roomname,ID,OwnerJID):
1061 Behaviour.OneShotBehaviour.__init__(self) 1062 self.ID=ID 1063 self.muc_name=muc_name 1064 self.name=roomname 1065 self.OwnerJID=OwnerJID 1066 self.result=None
1067
1068 - def _process(self):
1069 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1070 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1071 item= Node(tag="item", attrs={"affiliation":"owner"}) 1072 query.addChild(node=item) 1073 iq.addChild(node=query) 1074 self.myAgent.jabber.send(iq) 1075 msg = self._receive(True,10) 1076 exists=False 1077 if msg: 1078 if msg.getAttr("type")!="result": 1079 print msg.getError() #completar un poco el error 1080 return 1081 query = msg.getQueryChildren() 1082 if query: 1083 iqAns = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1084 queryAns = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1085 for item in query: 1086 if str(item.getAttr("jid"))==self.OwnerJID: 1087 i=Node(tag="item",attrs={"affiliation":"member","jid":self.OwnerJID}) 1088 queryAns.addChild(node=i) 1089 exists=True 1090 iqAns.addChild(node=queryAns) 1091 self.myAgent.jabber.send(iqAns) 1092 msgAns = self._receive(True,10) 1093 if msgAns: 1094 if msgAns.getAttr("type")!="result": 1095 error=msgAns.getTag("error") 1096 if error.getAttr("code")=="409": 1097 raise LastOwner 1098 else: 1099 exists=True 1100 if not exists: 1101 print "The JID "+self.OwnerJID+" doesn't belong to a owner" 1102 return 1103 print "Error"#completar un poco el error "No se pudede quitar al unico owner"
1104
1105 - def addModerator(self,newModeratorJID):
1106 if self.state=="unavailable": 1107 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1108 return 1109 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1110 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1111 t = Behaviour.MessageTemplate(p) 1112 b=self.AddModeratorBehaviour(self.muc_name,self.name,ID,newModeratorJID) 1113 self.myAgent.addBehaviour(b, t) 1114 b.join()
1115
1116 - class AddModeratorBehaviour(Behaviour.OneShotBehaviour):
1117 - def __init__(self,muc_name,roomname,ID,newModeratorJID):
1118 Behaviour.OneShotBehaviour.__init__(self) 1119 self.ID=ID 1120 self.muc_name=muc_name 1121 self.name=roomname 1122 self.newModeratorJID=newModeratorJID 1123 self.result=None
1124
1125 - def _process(self):
1126 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1127 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1128 item= Node(tag="item", attrs={"role":"moderator","JID":self.newModeratorJID}) 1129 query.addChild(node=item) 1130 iq.addChild(node=query) 1131 self.myAgent.jabber.send(iq) 1132 msg = self._receive(True,10) 1133 if msg: 1134 if msg.getAttr("type")!="result": 1135 print msg.getError() #completar un poco el error
1136 1137
1138 - def removeModerator(self,moderatorJID):
1139 if self.state=="unavailable": 1140 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1141 return 1142 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1143 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1144 t = Behaviour.MessageTemplate(p) 1145 b=self.RemoveModeratorBehaviour(self.muc_name,self.name,ID,moderatorJID) 1146 self.myAgent.addBehaviour(b, t) 1147 b.join()
1148
1149 - class RemoveModeratorBehaviour(Behaviour.OneShotBehaviour):
1150 - def __init__(self,muc_name,roomname,ID,moderatorJID):
1151 Behaviour.OneShotBehaviour.__init__(self) 1152 self.ID=ID 1153 self.muc_name=muc_name 1154 self.name=roomname 1155 self.moderatorJID=moderatorJID 1156 self.result=None
1157
1158 - def _process(self):
1159 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1160 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1161 item= Node(tag="item", attrs={"role":"moderator"}) 1162 query.addChild(node=item) 1163 iq.addChild(node=query) 1164 self.myAgent.jabber.send(iq) 1165 msg = self._receive(True,10) 1166 exists=False 1167 if msg: 1168 if msg.getAttr("type")!="result": 1169 print msg.getError() #completar un poco el error 1170 return 1171 query = msg.getQueryChildren() 1172 if query: 1173 iqAns = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1174 queryAns = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1175 for item in query: 1176 if item.getAttr("jid")==self.moderatorJID: 1177 i=Node(tag="item",attrs={"affiliation":"member","jid":self.moderatorJID}) 1178 queryAns.addChild(node=i) 1179 else: 1180 exists=True 1181 self.myAgent.register_mailbox(typ="iq",id=self.ID) 1182 iqAns.addChild(node=queryAns) 1183 self.myAgent.jabber.send(iqAns) 1184 msgAns = self._receive(True,10) 1185 if msgAns: 1186 if msgAns.getAttr("type")!="result": 1187 print msgAns.getError() #completar un poco el error 1188 if not exists: 1189 print "The JID "+self.moderatorJID+" doesn't belong to a owner" 1190 print "Error"#completar un poco el error
1191 1192
1193 - def getModeratorList(self):
1194 if self.state=="unavailable": 1195 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1196 return 1197 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1198 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1199 t = Behaviour.MessageTemplate(p) 1200 b=self.GetModeratorListBehaviour(self.muc_name,self.name,ID) 1201 self.myAgent.addBehaviour(b, t) 1202 b.join() 1203 return b.result
1204
1205 - class GetModeratorListBehaviour(Behaviour.OneShotBehaviour):
1206 - def __init__(self,muc_name,roomname,ID):
1207 Behaviour.OneShotBehaviour.__init__(self) 1208 self.ID=ID 1209 self.muc_name=muc_name 1210 self.name=roomname 1211 self.result=None
1212
1213 - def _process(self):
1214 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1215 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1216 item= Node(tag="item", attrs={"role":"moderator"}) 1217 query.addChild(node=item) 1218 iq.addChild(node=query) 1219 self.myAgent.jabber.send(iq) 1220 msg = self._receive(True,10) 1221 if msg: 1222 if msg.getAttr("type")!="result": 1223 print msg.getError() #completar un poco el error 1224 return 1225 query = msg.getQueryChildren() 1226 if query: 1227 #items =query.getChildren() 1228 owners=[] 1229 for item in query: 1230 if item.getAttr("jid"): 1231 owners.append(str(item.getAttr("jid"))) 1232 self.result=owners 1233 return 1234 print "Error"#completar un poco el error
1235 1236 1237
1238 - def leave(self):
1239 """ 1240 Agent leaves and it is removed from the member list 1241 """ 1242 if self.state=="unavailable": 1243 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1244 return 1245 owners=self.getOwnerList() 1246 if self.myAgent.JID not in owners or len(owners)>1: 1247 p = Presence(to=self.name+"@"+self.muc_name+"/"+self.nick,typ="unavailable") 1248 self.myAgent.jabber.send(p) 1249 self.state="unavailable" 1250 self.myAgent.removeBehaviour(self.presenceBehaviour) 1251 self.myAgent.removeBehaviour(self) 1252 else: 1253 raise LastOwner
1254
1255 - def destroy(self):
1256 """ 1257 Unit owner destroys the unit 1258 """ 1259 if self.state=="unavailable": 1260 print "The "+self.UnavailableMsg+" "+self.name+" is unavailable" 1261 return 1262 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1263 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1264 t1 = Behaviour.MessageTemplate(p) 1265 b=self.DestroyBehaviour(self.muc_name,self.name,ID,self.parent) 1266 self.myAgent.addBehaviour(b, t1) 1267 b.join() 1268 if b.result: 1269 #destruir los comportamientos 1270 self.myAgent.removeBehaviour(self.presenceBehaviour) 1271 self.myAgent.removeBehaviour(self) 1272 self.state="unavailable"
1273 1274
1275 - class DestroyBehaviour(Behaviour.OneShotBehaviour):
1276 - def __init__(self,muc_name,roomname,ID,parent):
1277 Behaviour.OneShotBehaviour.__init__(self) 1278 self.ID=ID 1279 self.muc_name=muc_name 1280 self.name=roomname 1281 self.parent=parent 1282 self.result=False
1283
1284 - def _process(self):
1285 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1286 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#owner") 1287 item= Node(tag="destroy") 1288 query.addChild(node=item) 1289 iq.addChild(node=query) 1290 self.myAgent.jabber.send(iq) 1291 msg = self._receive(True,10) 1292 if msg: 1293 if msg.getAttr("type")!="result": 1294 #print "Error: This agent is not a owner of the organization" 1295 print msg.getError() 1296 return 1297 else: 1298 #Desregistrando del OMS 1299 #dad = DF.DfAgentDescription() 1300 #sd = DF.DFServiceDescription() 1301 #sd.setName(self.name) 1302 #sd.setType("Unit: "+self.parent) 1303 #dad.addService(sd) 1304 #res = self.myAgent.deregisterService(dad) 1305 #print res 1306 self.result=True 1307 return 1308 print "Error: el mensaje no se ha recibido"
1309
1310 - class PresenceBehaviour(Behaviour.Behaviour):
1311 - def __init__(self,muc_name,roomname,nick,unit):
1312 Behaviour.Behaviour.__init__(self) 1313 self.muc_name=muc_name 1314 self.name=roomname 1315 self.nick=nick 1316 self.unit=unit
1317 1318
1319 - def _process(self):
1320 msg = self._receive(True,10) 1321 if msg: 1322 if msg.getType()=="unavailable": 1323 if msg.getRole()=="none" and msg.getFrom()==self.name+"@"+self.muc_name+"/"+self.nick: 1324 x=msg.getTag("x") 1325 if x: 1326 self.unit.state="unavailable" 1327 destroy=x.getTag("destroy") 1328 if destroy: 1329 print "The room has been destroyed" 1330 return 1331 if msg.getStatusCode()=="301": 1332 print "You have been baned" 1333 return 1334 else : 1335 if msg.getStatusCode()=="307": 1336 print "You have been kicked" 1337 return 1338 print "You have left the room" 1339 else: 1340 if msg.getFrom() in self.unit.members: 1341 self.unit.members.remove(msg.getFrom()) 1342 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1343 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1344 t1 = Behaviour.MessageTemplate(p) 1345 b=self.MinAgentsBehaviour(self.muc_name,self.name,ID,self.unit) 1346 self.myAgent.addBehaviour(b, t1) 1347 else: 1348 if (msg.getAffiliation()=="admin" or msg.getAffiliation()=="owner") and msg.getFrom()==self.name+"@"+self.muc_name+"/"+self.nick: 1349 self.unit.owner_admin=True 1350 if msg.getAffiliation()=="member" and msg.getFrom()==self.name+"@"+self.muc_name+"/"+self.nick: 1351 self.unit.owner_admin=False 1352 if self.unit.owner_admin: 1353 if msg.getFrom() not in self.unit.members: 1354 self.unit.members.append(msg.getFrom()) 1355 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1356 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1357 t1 = Behaviour.MessageTemplate(p) 1358 b=self.MinAgentsBehaviour(self.muc_name,self.name,ID,self.unit) 1359 self.myAgent.addBehaviour(b, t1)
1360
1361 - class MinAgentsBehaviour(Behaviour.OneShotBehaviour):
1362 - def __init__(self,muc_name,roomname,ID,unit):
1363 Behaviour.OneShotBehaviour.__init__(self) 1364 self.ID=ID 1365 self.muc_name=muc_name 1366 self.name=roomname 1367 self.result=[] 1368 self.unit=unit
1369
1370 - def _process(self):
1371 minAgents=None 1372 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1373 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 1374 iq.addChild(node=query) 1375 self.myAgent.jabber.send(iq) 1376 msg = self._receive(True,10) 1377 if msg: 1378 query = msg.getTag("query") 1379 if query: 1380 x = query.getTag("x") 1381 items =x.getChildren() 1382 for item in items: 1383 if item.getAttr("var")=="muc#roominfo_minusers": 1384 minAgents=item.getTags("value")[0].getData() 1385 agents=None 1386 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1387 query = Protocol('query',xmlns="http://jabber.org/protocol/disco#info") 1388 iq.addChild(node=query) 1389 self.myAgent.jabber.send(iq) 1390 msg = self._receive(True,10) 1391 if msg: 1392 query = msg.getTag("query") 1393 if query: 1394 x = query.getTag("x") 1395 if x: 1396 items =x.getChildren() 1397 for item in items: 1398 if item.getAttr("var")=="muc#roominfo_occupants": 1399 agents=item.getTags("value")[0].getData() 1400 if agents and minAgents and int(agents)<int(minAgents): 1401 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1402 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1403 item= Node(tag="item", attrs={"role":"participant"}) 1404 query.addChild(node=item) 1405 iq.addChild(node=query) 1406 self.myAgent.jabber.send(iq) 1407 msg=self._receive(True,10) 1408 if msg: 1409 error=msg.getError() 1410 if error!=None: 1411 print error 1412 return 1413 q = msg.getTag("query") 1414 if q: 1415 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1416 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1417 items =q.getChildren() 1418 for item in items: 1419 i= Node(tag="item", attrs={"jid":str(item.getAttr("jid")),"role":"visitor"}) 1420 query.addChild(node=i) 1421 iq.addChild(node=query) 1422 self.myAgent.jabber.send(iq) 1423 self.unit.state="locked" 1424 if agents and minAgents and int(agents)>int(minAgents) and self.unit.state=="locked": 1425 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1426 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1427 item= Node(tag="item", attrs={"role":"visitor"}) 1428 query.addChild(node=item) 1429 iq.addChild(node=query) 1430 self.myAgent.jabber.send(iq) 1431 msg=self._receive(True,10) 1432 if msg: 1433 error=msg.getError() 1434 if error!=None: 1435 print error 1436 return 1437 q = msg.getTag("query") 1438 if q: 1439 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1440 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1441 items =q.getChildren() 1442 for item in items: 1443 i= Node(tag="item", attrs={"jid":str(item.getAttr("jid")),"role":"visitor"}) 1444 query.addChild(node=i) 1445 iq.addChild(node=query) 1446 self.myAgent.jabber.send(iq) 1447 self.unit.state="available"
1448
1449 - def kickAgent(self,agentNick):
1450 if self.state=="unavailable": 1451 raise Unavailable 1452 return 1453 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1454 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1455 t = Behaviour.MessageTemplate(p) 1456 b=self.KickAgentBehaviour(self.muc_name,self.name,ID,agentNick) 1457 self.myAgent.addBehaviour(b, t) 1458 b.join() 1459 return b.result
1460
1461 - class KickAgentBehaviour(Behaviour.OneShotBehaviour):
1462 - def __init__(self,muc_name,roomname,ID,agentNick):
1463 Behaviour.OneShotBehaviour.__init__(self) 1464 self.ID=ID 1465 self.muc_name=muc_name 1466 self.name=roomname 1467 self.agentNick=agentNick 1468 self.result=None
1469
1470 - def _process(self):
1471 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1472 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1473 item= Node(tag="item", attrs={"role":"none","nick":self.agentNick}) 1474 query.addChild(node=item) 1475 iq.addChild(node=query) 1476 self.myAgent.jabber.send(iq) 1477 msg = self._receive(True,10) 1478 if msg: 1479 if msg.getAttr("type")!="result": 1480 print msg.getError()
1481
1482 - def addBanAgent(self,agentJID):
1483 if self.state=="unavailable": 1484 raise Unavailable 1485 return 1486 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1487 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1488 t = Behaviour.MessageTemplate(p) 1489 b=self.AddBanAgentBehaviour(self.muc_name,self.name,ID,agentJID) 1490 self.myAgent.addBehaviour(b, t) 1491 b.join() 1492 return b.result
1493
1494 - class AddBanAgentBehaviour(Behaviour.OneShotBehaviour):
1495 - def __init__(self,muc_name,roomname,ID,agentJID):
1496 Behaviour.OneShotBehaviour.__init__(self) 1497 self.ID=ID 1498 self.muc_name=muc_name 1499 self.name=roomname 1500 self.agentJID=agentJID 1501 self.result=None
1502
1503 - def _process(self):
1504 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1505 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1506 item= Node(tag="item", attrs={"affiliation":"outcast","jid":self.agentJID}) 1507 query.addChild(node=item) 1508 iq.addChild(node=query) 1509 self.myAgent.jabber.send(iq) 1510 msg = self._receive(True,10) 1511 if msg: 1512 if msg.getAttr("type")!="result": 1513 print "Error" #completar un poco el error
1514
1515 - def removeBanAgent(self,agentJID):
1516 if self.state=="unavailable": 1517 raise Unavailable 1518 return 1519 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1520 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1521 t = Behaviour.MessageTemplate(p) 1522 b=self.RemoveBanAgentBehaviour(self.muc_name,self.name,ID,agentJID) 1523 self.myAgent.addBehaviour(b, t) 1524 b.join() 1525 return b.result
1526
1527 - class RemoveBanAgentBehaviour(Behaviour.OneShotBehaviour):
1528 - def __init__(self,muc_name,roomname,ID,agentJID):
1529 Behaviour.OneShotBehaviour.__init__(self) 1530 self.ID=ID 1531 self.muc_name=muc_name 1532 self.name=roomname 1533 self.agentJID=agentJID 1534 self.result=None
1535
1536 - def _process(self):
1537 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1538 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1539 item= Node(tag="item", attrs={"affiliation":"outcast"}) 1540 query.addChild(node=item) 1541 iq.addChild(node=query) 1542 self.myAgent.jabber.send(iq) 1543 msg = self._receive(True,10) 1544 exists=False 1545 if msg: 1546 if msg.getAttr("type")!="result": 1547 print msg.getError() #completar un poco el error 1548 return 1549 query = msg.getQueryChildren() 1550 if query: 1551 iqAns = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1552 queryAns = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1553 for item in query: 1554 if item.getAttr("jid")==self.agentJID: 1555 queryAns.addChild(node=item) 1556 else: 1557 exists=True 1558 iqAns.addChild(node=queryAns) 1559 self.myAgent.jabber.send(iqAns) 1560 msgAns = self._receive(True,10) 1561 if msgAns: 1562 if msgAns.getAttr("type")!="result": 1563 print msgAns.getError() #completar un poco el error 1564 if not exists: 1565 print "The JID "+self.agentJID+" doesn't belong to a banned agent" 1566 return 1567 print "Error"#completar un poco el error
1568
1569 - def getBanAgentList(self):
1570 if self.state=="unavailable": 1571 raise Unavailable 1572 return 1573 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1574 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1575 t = Behaviour.MessageTemplate(p) 1576 b=self.GetBanAgentListBehaviour(self.muc_name,self.name,ID) 1577 self.myAgent.addBehaviour(b, t) 1578 b.join() 1579 return b.result
1580
1581 - class GetBanAgentListBehaviour(Behaviour.OneShotBehaviour):
1582 - def __init__(self,muc_name,roomname,ID):
1583 Behaviour.OneShotBehaviour.__init__(self) 1584 self.ID=ID 1585 self.muc_name=muc_name 1586 self.name=roomname 1587 self.result=None
1588
1589 - def _process(self):
1590 BanedList=[] 1591 iq = Iq(to=self.name+"@"+self.muc_name,typ='get', attrs={"id":self.ID}) 1592 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1593 item= Node(tag="item", attrs={"affiliation":"outcast"}) 1594 query.addChild(node=item) 1595 iq.addChild(node=query) 1596 self.myAgent.jabber.send(iq) 1597 msg = self._receive(True,10) 1598 if msg: 1599 if msg.getAttr("type")!="result": 1600 print msg.getError() #completar un poco el error 1601 return 1602 query = msg.getQueryChildren() 1603 if query: 1604 for item in query: 1605 if item.getAttr("jid"): 1606 BanedList.append(str(item.getAttr("jid"))) 1607 self.result=BanedList
1608 1609 1610 1611
1612 - def giveVoice(self,nickname):
1613 if self.state=="unavailable": 1614 raise Unavailable 1615 return 1616 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1617 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1618 t = Behaviour.MessageTemplate(p) 1619 b=self.GiveVoiceBehaviour(self.muc_name,self.name,ID,nickname) 1620 self.myAgent.addBehaviour(b, t) 1621 b.join()
1622
1623 - class GiveVoiceBehaviour(Behaviour.OneShotBehaviour):
1624 - def __init__(self,muc_name,roomname,ID,nickname):
1625 Behaviour.OneShotBehaviour.__init__(self) 1626 self.ID=ID 1627 self.muc_name=muc_name 1628 self.name=roomname 1629 self.nickname=nickname 1630 self.result=None
1631
1632 - def _process(self):
1633 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1634 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1635 item= Node(tag="item", attrs={"nick":self.nickname,"role":"participant"}) 1636 query.addChild(node=item) 1637 iq.addChild(node=query) 1638 self.myAgent.jabber.send(iq) 1639 msg = self._receive(True,10) 1640 if msg: 1641 if msg.getAttr("type")!="result": 1642 print msg.getError() #completar un poco el error
1643
1644 - def revokeVoice(self,nickname):
1645 if self.state=="unavailable": 1646 raise Unavailable 1647 return 1648 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1649 p = Iq(frm=self.name+"@"+self.muc_name, attrs={"id":ID}) 1650 t = Behaviour.MessageTemplate(p) 1651 b=self.RevokeVoiceBehaviour(self.muc_name,self.name,ID,nickname) 1652 self.myAgent.addBehaviour(b, t) 1653 b.join()
1654
1655 - class RevokeVoiceBehaviour(Behaviour.OneShotBehaviour):
1656 - def __init__(self,muc_name,roomname,ID,nickname):
1657 Behaviour.OneShotBehaviour.__init__(self) 1658 self.ID=ID 1659 self.muc_name=muc_name 1660 self.name=roomname 1661 self.nickname=nickname 1662 self.result=None
1663
1664 - def _process(self):
1665 iq = Iq(to=self.name+"@"+self.muc_name,typ='set', attrs={"id":self.ID}) 1666 query = Protocol('query',xmlns="http://jabber.org/protocol/muc#admin") 1667 item= Node(tag="item", attrs={"nick":self.nickname,"role":"visitor"}) 1668 query.addChild(node=item) 1669 iq.addChild(node=query) 1670 self.myAgent.jabber.send(iq) 1671 msg = self._receive(True,10) 1672 if msg: 1673 if msg.getAttr("type")!="result": 1674 print msg.getError() #completar un poco el error
1675 1676 1677
1678 - def sendMessage(self,message):
1679 if self.state=="unavailable": 1680 raise Unavailable 1681 return 1682 p=Message(frm=self.name+"@"+self.muc_name,typ="error") 1683 t = Behaviour.MessageTemplate(p) 1684 b=self.SendMessageBehaviour(self.muc_name,self.name,message) 1685 self.myAgent.addBehaviour(b, t) 1686 b.join()
1687
1688 - class SendMessageBehaviour(Behaviour.OneShotBehaviour):
1689 - def __init__(self,muc_name,roomname,message):
1690 Behaviour.OneShotBehaviour.__init__(self) 1691 self.muc_name=muc_name 1692 self.name=roomname 1693 self.message=message
1694
1695 - def _process(self):
1696 m=Message(to=self.name+"@"+self.muc_name,typ="groupchat") 1697 x=Node(tag="body") 1698 x.addData(self.message) 1699 m.addChild(node=x) 1700 self.myAgent.jabber.send(m) 1701 msg = self._receive(True,10) 1702 if msg: 1703 print "This message can't be sent"
1704 #falta comprobar la respuesta del servidor forbidden o not-acceptable(este no deberia producirse) 1705
1706 - def sendPrivateMessage(self,recName,message):
1707 if self.state=="unavailable": 1708 raise Unavailable 1709 return 1710 p=Message(frm=self.name+"@"+self.muc_name,typ="error") 1711 t = Behaviour.MessageTemplate(p) 1712 b=self.SendPrivateMessageBehaviour(recName,message) 1713 self.myAgent.addBehaviour(b, t) 1714 b.join()
1715
1716 - class SendPrivateMessageBehaviour(Behaviour.OneShotBehaviour):
1717 - def __init__(self,recName,message):
1718 Behaviour.OneShotBehaviour.__init__(self) 1719 self.recName=recName 1720 self.message=message
1721
1722 - def _process(self):
1723 m=Message(to=self.recName,typ="chat") 1724 x=Node(tag="body") 1725 x.addData(message) 1726 m.addChild(node=x) 1727 self.myAgent.jabber.send(m) 1728 msg = self._receive(True,10) 1729 if msg: 1730 print "This message can't be sent"
1731 #falta comprobar si la respuesta del servidorforbidden o not-acceptable(este no deberia producirse) 1732
1733 - def setRegistrationForm(self,dataForm):
1734 pass
1735 - def addUnit(self,unit):
1736 """ 1737 Creates a new unit inside an organization 1738 """ 1739 if self.state=="unavailable": 1740 raise Unavailable 1741 return 1742 if self.checkTypes(self.parent_type,unit.type): 1743 #un sitwch para aquellas organizaciones donde todos puedan crear unidades 1744 if self.parent_type!="Matrix" and self.parent_type!="Federation": 1745 if self.myAgent.JID in self.getAdminList(): 1746 unit.create=True 1747 unit.parent=self.parent 1748 unit.parent_type=self.parent_type 1749 self.myAgent.addBehaviour(unit) 1750 else: 1751 raise NotAdmin 1752 elif self.checkSupervisor(self.myAgent.JID): 1753 unit.create=True 1754 unit.parent=self.parent 1755 unit.parent_type=self.parent_type 1756 self.myAgent.addBehaviour(unit) 1757 else: 1758 raise NotSupervisor 1759 else: 1760 raise NotValidType
1761 1762
1763 - def checkTypes(self,orgType,unitType):
1764 if orgType=="Flat": 1765 return True 1766 if orgType=="Team" and unitType=="Team": 1767 return True 1768 if orgType=="Hierarchy" and unitType=="Hierarchy": 1769 return True 1770 if orgType=="Bureaucracy" and unitType=="Hierarchy": 1771 return True 1772 if orgType=="Matrix" and unitType=="Hierarchy": 1773 return True 1774 if orgType=="Federation" and unitType=="Hierarchy": 1775 return True 1776 if orgType=="Coalition" and unitType=="Team": 1777 return True 1778 if orgType=="Congregation" and unitType=="Hierarchy": 1779 return True 1780 if orgType=="Congregation" and unitType=="Team": 1781 return True 1782 if orgType=="Congregation" and unitType=="Flat": 1783 return True 1784 return False
1785
1786 - def checkSupervisor(self,myAgentJID):
1787 supervisor=self.getSupervisorList() 1788 if myAgentJID in supervisor: 1789 return True 1790 else: 1791 return False
1792 1793
1794 - def getSupervisorList(self):
1795 list=[] 1796 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1797 p = Iq(frm="Team:"+self.parent+"@"+self.muc_name, attrs={"id":ID}) 1798 t1 = Behaviour.MessageTemplate(p) 1799 b=self.GetMemberListBehaviour(self.muc_name,"Team:"+self.parent,ID) 1800 self.myAgent.addBehaviour(b, t1) 1801 b.join() 1802 member=b.result 1803 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1804 p = Iq(frm="Team:"+self.parent+"@"+self.muc_name, attrs={"id":ID}) 1805 t = Behaviour.MessageTemplate(p) 1806 b=self.GetOwnerListBehaviour(self.muc_name,"Team:"+self.parent,ID) 1807 self.myAgent.addBehaviour(b, t) 1808 b.join() 1809 owner=b.result 1810 ID="".join([string.ascii_letters[int(random.randint(0,len(string.ascii_letters)-1))] for a in range(5)]) 1811 p = Iq(frm="Team:"+self.parent+"@"+self.muc_name, attrs={"id":ID}) 1812 t = Behaviour.MessageTemplate(p) 1813 b=self.GetAdminListBehaviour(self.muc_name,"Team:"+self.parent,ID) 1814 self.myAgent.addBehaviour(b, t) 1815 b.join() 1816 admin=b.result 1817 for i in owner: 1818 list.append(i) 1819 for i in member: 1820 list.append(i) 1821 for i in admin: 1822 list.append(i) 1823 return list
1824
1825 - def run(self):
1826 if self.create: 1827 self.myCreate() 1828 else: 1829 self.myJoin() 1830 self.onStart() 1831 while (not self.done()) and (not self._forceKill.isSet()): 1832 self._process() 1833 #time.sleep(0) 1834 self.onEnd() 1835 self.myAgent.removeBehaviour(self)
1836
1837 - def _process(self):
1838 pass
1839 1840 """ 1841 def run(self): 1842 if self.create: 1843 self.myCreate() 1844 else: 1845 self.myJoin() 1846 self.onStart() 1847 while (not self.done()) and (not self._forceKill.isSet()): 1848 self._process() 1849 #time.sleep(0) 1850 self.onEnd() 1851 self.myAgent.removeBehaviour(self) 1852 1853 1854 def addUNit(self,Name,Type,GoalList,AgentList): 1855 if checkTypes(self.type,Type): 1856 if checkOwner(self.myAgent.getJID()): 1857 return Unit(self.myAgent,self.nick,Name,Type,GoalList,AgentList) 1858 else: 1859 print "The Agent isn't the owner of the Organization" 1860 else: 1861 print "Unit Type is not a valid type" 1862 1863 def checkTypes(orgType,unitType): 1864 if orgType=="Flat": 1865 return True 1866 if orgType=="Team" and unitType=="Team": 1867 return True 1868 if orgType=="Hierarchy" and unitType=="Hierarchy": 1869 return True 1870 if orgType=="Bureaucracy" and unitType=="Hierarchy": 1871 return True 1872 if orgType=="Matrix" and unitType=="Team": 1873 return True 1874 if orgType=="Matrix" and unitType=="Hierarchy": 1875 return True 1876 if orgType=="Federation" and unitType=="Team": 1877 return True 1878 if orgType=="Federation" and unitType=="Hierarchy": 1879 return True 1880 if orgType=="Coalition" and unitType=="Team": 1881 return True 1882 if orgType=="Congregation" and unitType=="Hierarchy": 1883 return True 1884 if orgType=="Congregation" and unitType=="Team": 1885 return True 1886 if orgType=="Congregation" and unitType=="Flat": 1887 return True 1888 return False 1889 1890 def checkOwner(self,agentJID): 1891 ownerList=getOwnerList() 1892 try: 1893 ownerList.index(agentJID) 1894 except: 1895 return False 1896 return True 1897 1898 def join(self): 1899 p = Presence(to=self.name+"@"+self.muc_name+"/"+self.nick) 1900 x = Protocol("x", xmlns="http://jabber.org/protocol/muc") 1901 p.addChild(node=x) 1902 self.myAgent.jabber.send(p) 1903 #Falta comprobar que se ha unido a la sala sin problemas 1904 return True 1905 1906 1907 def setRegistrationForm(self,dataForm): 1908 pass 1909 1910 1911 1912 """ 1913