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

Source Code for Module spade.Unit_new

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