1
2 import random
3 import string
4
5 from xmpp import *
6 from Queue import *
7 import Behaviour
8
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)])
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
92
93
94
95
96
126
128
129 if not self.testUnitName():
130 raise NotValidName
131
132 elif not self.myJoinRoom():
133 raise JoinError
134
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
161
162
163
164
165
167 - def __init__(self,ID,muc_name,roomname):
173
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
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
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
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
239 while msg and msg.getName()!="iq":
240 msg = self._receive(True,10)
241
242
243 if not msg or msg.getAttr("type")=="error":
244 print "No configuration is possible: "+msg.getError()
245
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
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]
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
298 if item.getAttr("var") == "muc#roomconfig_changesubject":
299 value="1"
300 if item.getAttr("var") == "muc#roomconfig_allowinvites":
301 value="1"
302
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":
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
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
344
346 - def __init__(self,muc_name,roomname,nick,password):
353
381
382
384
385 if goalList!=None:
386 return True
387 else:
388 return False
389
390
392 types=("Flat","Team","Hierarchy")
393 if self.type in types:
394 return True
395 return False
396
398 info=self.getInfo()
399 if info:
400 if info["parent"]!="Organization" and info["parent"]!="":
401 return True
402 return False
403
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
420 """
421 Updates organization goals
422 """
423
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
439 - def __init__(self,muc_name,roomname,goalList,ID):
445
455
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
473 - def __init__(self,muc_name,roomname,ID):
479
500
501
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
513 - def __init__(self,muc_name,roomname,ID):
519
550
551
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
568 - def __init__(self,muc_name,roomname,ID):
574
599
600
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
617 - def __init__(self,muc_name,roomname,ID):
623
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
659 - def __init__(self,muc_name,roomname,ID):
665
684
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
700 - def __init__(self,muc_name,roomname,ID,maxUsers):
706
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"
715 return
716
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]
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")
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
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
758 - def __init__(self,muc_name,roomname,ID,minUsers):
764
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"
774 return
775 self.myAgent.register_mailbox(typ="iq",id=self.ID)
776
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]
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")
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
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
819 - def __init__(self,muc_name,roomname,ID):
825
845
846
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
860 - def __init__(self,muc_name,roomname,ID):
866
888
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
901 - def __init__(self,muc_name,roomname,ID,newAdminJID):
908
920
921
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
935 - def __init__(self,muc_name,roomname,ID,newAdminJID):
942
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()
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()
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"
977
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
991 - def __init__(self,muc_name,roomname,ID):
997
1019
1020
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
1033 - def __init__(self,muc_name,roomname,ID,newModeratorJID):
1040
1052
1053
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
1066 - def __init__(self,muc_name,roomname,ID,moderatorJID):
1073
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()
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()
1104 if not exists:
1105 print "The JID "+self.moderatorJID+" doesn't belong to a owner"
1106 print "Error"
1107
1108
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
1122 - def __init__(self,muc_name,roomname,ID):
1128
1151
1152
1153
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
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
1185 self.myAgent.removeBehaviour(self.presenceBehaviour)
1186 self.myAgent.removeBehaviour(self)
1187 self.state="unavailable"
1188 else:
1189 raise DestroyError
1190
1191
1193 - def __init__(self,muc_name,roomname,ID,parent):
1200
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
1212 print msg.getError()
1213 return
1214 else:
1215
1216
1217
1218
1219
1220
1221
1222
1223 self.result=True
1224 return
1225 print "Error: el mensaje no se ha recibido"
1226
1228 - def __init__(self,muc_name,roomname,nick,unit):
1234
1235
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
1275 - def __init__(self,muc_name,roomname,ID,unit):
1282
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
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
1375 - def __init__(self,muc_name,roomname,ID,agentNick):
1382
1394
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
1408 - def __init__(self,muc_name,roomname,ID,agentJID):
1415
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"
1427
1439
1441 - def __init__(self,muc_name,roomname,ID,agentJID):
1448
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()
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()
1477 if not exists:
1478 print "The JID "+self.agentJID+" doesn't belong to a banned agent"
1479 return
1480 print "Error"
1481
1493
1495 - def __init__(self,muc_name,roomname,ID):
1501
1521
1522
1523
1524
1535
1537 - def __init__(self,muc_name,roomname,ID,nickname):
1544
1556
1567
1569 - def __init__(self,muc_name,roomname,ID,nickname):
1576
1588
1589
1590
1600
1602 - def __init__(self,muc_name,roomname,message):
1607
1617
1618
1628
1644
1645
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
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
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
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
1720 supervisor=self.getSupervisorList()
1721 if myAgentJID in supervisor:
1722 return True
1723 else:
1724 return False
1725
1726
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
1769
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