1
2 import random
3 import string
4
5 from xmpp import *
6 from Queue import *
7 import Behaviour
8
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)])
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
91
92
93
94
95
125
127
128 if not self.testUnitName():
129 raise NotValidName
130
131 elif not self.myJoinRoom():
132 raise JoinError
133
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
160
161
162
163
164
166 - def __init__(self,ID,muc_name,roomname):
172
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
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
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
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
238 while msg and msg.getName()!="iq":
239 msg = self._receive(True,10)
240
241
242 if not msg or msg.getAttr("type")=="error":
243 print "No configuration is possible: "+msg.getError()
244
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
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]
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":
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
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
339
341 - def __init__(self,muc_name,roomname,nick,password):
348
376
377
379
380 if goalList!=None:
381 return True
382 else:
383 return False
384
385
387 types=("Flat","Team","Hierarchy")
388 if self.type in types:
389 return True
390 return False
391
393 info=self.getInfo()
394 if info:
395 if info["parent"]!="Organization" and info["parent"]!="":
396 return True
397 return False
398
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
415 """
416 Updates organization goals
417 """
418
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
434 - def __init__(self,muc_name,roomname,goalList,ID):
440
450
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
468 - def __init__(self,muc_name,roomname,ID):
474
495
496
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
508 - def __init__(self,muc_name,roomname,ID):
514
545
546
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
563 - def __init__(self,muc_name,roomname,ID):
569
594
595
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
612 - def __init__(self,muc_name,roomname,ID):
618
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
654 - def __init__(self,muc_name,roomname,ID):
660
679
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
695 - def __init__(self,muc_name,roomname,ID,maxUsers):
701
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"
710 return
711
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]
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")
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
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
753 - def __init__(self,muc_name,roomname,ID,minUsers):
759
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"
769 return
770 self.myAgent.register_mailbox(typ="iq",id=self.ID)
771
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]
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")
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
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
814 - def __init__(self,muc_name,roomname,ID):
820
840
841
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
855 - def __init__(self,muc_name,roomname,ID):
861
883
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
896 - def __init__(self,muc_name,roomname,ID,newAdminJID):
903
915
916
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
930 - def __init__(self,muc_name,roomname,ID,newAdminJID):
937
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()
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()
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"
972
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
986 - def __init__(self,muc_name,roomname,ID):
992
1014
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
1027 - def __init__(self,muc_name,roomname,ID,newOwnerJID):
1034
1046
1047
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
1060 - def __init__(self,muc_name,roomname,ID,OwnerJID):
1067
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()
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"
1104
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
1117 - def __init__(self,muc_name,roomname,ID,newModeratorJID):
1124
1136
1137
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
1150 - def __init__(self,muc_name,roomname,ID,moderatorJID):
1157
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()
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()
1188 if not exists:
1189 print "The JID "+self.moderatorJID+" doesn't belong to a owner"
1190 print "Error"
1191
1192
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
1206 - def __init__(self,muc_name,roomname,ID):
1212
1235
1236
1237
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
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
1270 self.myAgent.removeBehaviour(self.presenceBehaviour)
1271 self.myAgent.removeBehaviour(self)
1272 self.state="unavailable"
1273
1274
1276 - def __init__(self,muc_name,roomname,ID,parent):
1283
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
1295 print msg.getError()
1296 return
1297 else:
1298
1299
1300
1301
1302
1303
1304
1305
1306 self.result=True
1307 return
1308 print "Error: el mensaje no se ha recibido"
1309
1311 - def __init__(self,muc_name,roomname,nick,unit):
1317
1318
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
1362 - def __init__(self,muc_name,roomname,ID,unit):
1369
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
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
1462 - def __init__(self,muc_name,roomname,ID,agentNick):
1469
1481
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
1495 - def __init__(self,muc_name,roomname,ID,agentJID):
1502
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"
1514
1526
1528 - def __init__(self,muc_name,roomname,ID,agentJID):
1535
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()
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()
1564 if not exists:
1565 print "The JID "+self.agentJID+" doesn't belong to a banned agent"
1566 return
1567 print "Error"
1568
1580
1582 - def __init__(self,muc_name,roomname,ID):
1588
1608
1609
1610
1611
1622
1624 - def __init__(self,muc_name,roomname,ID,nickname):
1631
1643
1654
1656 - def __init__(self,muc_name,roomname,ID,nickname):
1663
1675
1676
1677
1687
1689 - def __init__(self,muc_name,roomname,message):
1694
1704
1705
1715
1731
1732
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
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
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
1787 supervisor=self.getSupervisorList()
1788 if myAgentJID in supervisor:
1789 return True
1790 else:
1791 return False
1792
1793
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
1836
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