source: n4d-server-plugins/trunk/fuentes/server-install-files/usr/share/n4d/python-plugins/Golem.py @ 180

Last change on this file since 180 was 180, checked in by hectorgh, 5 years ago

wip

File size: 25.5 KB
Line 
1# -*- coding: utf-8 -*-
2import imp
3import ldap
4import sys
5import subprocess
6import grp
7import shutil
8import threading
9import magic
10import pyinotify
11import time
12from pyinotify import WatchManager, Notifier, ThreadedNotifier, EventsCodes, ProcessEvent
13
14
15class Golem:
16
17
18        PLUGIN_PATH="/usr/share/n4d/python-plugins/"
19        LDAP_LOG="/var/lib/ldap/"
20       
21       
22        def startup(self,options):
23               
24               
25                try:
26                        self.mime=magic.open(magic.MAGIC_MIME)
27                        self.mime.load()
28                        self.obj=imp.load_source("LdapManager",Golem.PLUGIN_PATH + "LdapManager.py")
29                        obj3=imp.load_source("NetFilesManager",Golem.PLUGIN_PATH + "NetFilesManager.py")
30                        obj4=imp.load_source("PasswordManager",Golem.PLUGIN_PATH + "PasswordManager.py")
31                        obj5=imp.load_source("GesItaManager",Golem.PLUGIN_PATH + "GesItaManager.py")
32                        obj6=imp.load_source("FileOperations",Golem.PLUGIN_PATH + "FileOperations.py")
33                        obj7=imp.load_source("PeterPan",Golem.PLUGIN_PATH + "PeterPan.py")
34                        self.ldap=self.obj.LdapManager(llxvars)
35                        self.netfiles=obj3.NetFilesManager(llxvars)
36                        self.pw=obj4.PasswordManager()
37                        self.itaca=obj5.GesItaManager(llxvars,self,'llxgesc.xml')
38                        self.file_operations=obj6.FileOperations()
39                        self.peter_pan=obj7.PeterPan()
40                        self.try_count=0
41                        self.sharefunctions = {}
42                       
43                       
44                       
45                        if objects["VariablesManager"].get_variable("MASTER_SERVER_IP")!=None:
46                                p=subprocess.Popen(["gluster volume info"],shell=True,stdout=subprocess.PIPE,stderr=subprocess.PIPE).communicate()[1]
47                                if 'No volumes present' in p:
48                                        #Light version. Does not chown existing net files
49                                        self.regenerate_net_files(1)
50                                        self.start_inotify()
51                       
52                except Exception as e:
53                        print e
54               
55        #def __init__
56       
57
58        def start_inotify(self):
59
60                t=threading.Thread(target=self._inotify)
61                t.daemon=True
62                t.start()
63
64        #def start_inotify
65               
66        def _inotify(self):
67               
68                wm=WatchManager()
69                mask=pyinotify.ALL_EVENTS
70                       
71                class Process_handler(ProcessEvent):
72                               
73                        def __init__(self,main):
74                               
75                                self.main=main
76                                self.count=0
77                                self.in_modify=False
78                               
79                        def process_IN_MODIFY(self,event):
80                                if not self.in_modify:
81                                        self.in_modify=True
82                                        time.sleep(2)
83                                        # light version. Does not chown existing net files
84                                        self.main.regenerate_net_files(1)
85                                        time.sleep(2)
86                                        self.in_modify=False
87
88
89       
90                notifier=Notifier(wm,Process_handler(self))
91                wdd=wm.add_watch(Golem.LDAP_LOG,mask,rec=True)
92                       
93                while True:
94                        try:
95                                       
96                                notifier.process_events()
97                                if notifier.check_events():
98                                        notifier.read_events()
99                               
100                        except Exception as e:
101                                print e
102                                notifier.stop()
103                                       
104                return False
105       
106        #def _inotify
107       
108       
109       
110        def _restore_groups_folders(self):
111               
112                t=threading.Thread(target=self.restore_groups_folders)
113                t.daemon=True
114                t.start()
115               
116        #def
117
118        def add_user(self,plantille,properties,generic_mode=False):
119               
120               
121                generated_user=None
122                properties["uid"]=properties["uid"].encode("utf8")
123                properties["cn"]=properties["cn"].encode("utf8")
124                properties["sn"]=properties["sn"].encode("utf8")
125               
126               
127                if properties.has_key("userPassword"):
128                        properties["userPassword"]=properties["userPassword"].encode("utf8")
129               
130                if type(generic_mode)==type(True):
131                        #es un booleano
132                        generated_user=self.ldap.add_user(generic_mode,plantille,properties)
133                else:
134                        generated_user=self.ldap.add_user(False,plantille,properties)
135               
136                if type(generated_user) is dict:
137                       
138                        homepath = self.netfiles.exist_home_or_create(generated_user)
139                        if plantille=="Teachers" or plantille=="Others":
140                                self.pw.add_password(generated_user["uid"],generated_user["cn"],generated_user["sn"],generated_user["userPassword"])
141                        properties["group_type"]=plantille
142                        self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem','add_user',properties)
143                        self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','add_user',[properties])
144                        return "true: " + generated_user["uid"]
145                else:
146                        return generated_user
147               
148       
149        #def add_user
150       
151
152        def add_generic_users(self,plantille,group_type,number,generic_name,pwd_generation_type,pwd=None):
153               
154                generated_list=self.ldap.add_generic_users(plantille,group_type,number,generic_name,pwd_generation_type,pwd)
155                for item in generated_list:
156                        #
157                        # Item {uid:name,userPassword:password}
158                        #
159                       
160                        homepath = self.netfiles.exist_home_or_create(item)
161                       
162                        #print "password saving..."
163                        if plantille=="Teachers" or plantille=="Others":
164                                self.pw.add_password(item["uid"],item["cn"],item["sn"],item["userPassword"])
165                        self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('add_generic_users'),{'group':group_type,'user':item})
166
167                        properties = {}
168                        properties['group_type'] = plantille
169                        properties['uid'] = item['uid']
170                        properties['cn'] = item['uid']
171                        properties['sn'] = item['uid']
172                        self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','add_user',[properties])
173                return generated_list
174               
175        #def add_generic_users
176       
177        def add_admin(self,user_name):
178                # existing system user
179       
180                try:
181                        uid=pwd.getpwnam(user_name).pw_uid
182                       
183                        properties={}
184                        properties["uid"]=user_name
185                        properties["cn"]=user_name
186                        properties["sn"]=user_name
187                        properties["userPassword"]=uid
188                        properties["uidNumber"]=os.environ["SUDO_UID"]
189                       
190                        self.ldap.add_user(False,"Admin",properties)
191                        return True
192                       
193                except Exception as e:
194                       
195                        return [False,e.message]
196                       
197                       
198       
199        #def add_admin
200       
201        def login(self,user_info):
202               
203                uid,password=user_info
204               
205                dic={}
206                p = subprocess.Popen(["groups",uid],stdout = subprocess.PIPE,stderr = subprocess.PIPE)
207                output = p.communicate()[0]
208                output=output.replace("\n","")
209               
210                dic["groups"]=output
211               
212                students="ou=Students,ou=People," + llxvars("LDAP_BASE_DN")
213                teachers="ou=Teachers,ou=People," + llxvars("LDAP_BASE_DN")
214                admins="ou=Admins,ou=People," + llxvars("LDAP_BASE_DN")
215               
216                group_type="None"
217               
218                if output.find("students")!=-1:
219                        dic["path"]="uid=" + uid + "," + students
220                        group_type="students"
221                       
222                if output.find("teachers")!=-1:
223                        dic["path"]="uid=" + uid + "," + teachers
224                        group_type="teachers"
225
226                if output.find("admins")!=-1 and output.find("teachers")!=-1:
227                        dic["path"]="uid=" + uid + "," + teachers
228                        group_type="promoted-teacher"
229               
230                if output.find("adm")!=-1:
231                        dic["path"]="uid=" + uid + "," + admins
232                        group_type="admin"
233                        #return "true " + group_type
234
235                if "NTicketsManager" in objects:
236                        if objects["NTicketsManager"].validate_user(uid,password):
237                                return "true " + group_type
238                       
239                if validate_user(uid,password)[0]:
240                        return "true "+ group_type
241                else:
242                        return "false"
243
244               
245        #def login
246       
247       
248       
249        def change_own_password(self,user_info,new_password):
250               
251                uid,password=user_info
252                dic={}
253                p = subprocess.Popen(["groups",uid],stdout = subprocess.PIPE,stderr = subprocess.PIPE)
254                output = p.communicate()[0]
255                output=output.replace("\n","")
256               
257                dic["groups"]=output
258               
259                students="ou=Students,ou=People," + llxvars("LDAP_BASE_DN")
260                teachers="ou=Teachers,ou=People," + llxvars("LDAP_BASE_DN")
261                admin="ou=Admins,ou=People," + llxvars("LDAP_BASE_DN")
262                others="ou=Other,ou=People," + llxvars("LDAP_BASE_DN")
263               
264                if output.find("students")!=-1:
265                        path="uid=" + uid + "," + students
266                elif output.find("teachers")!=-1:
267                        path="uid=" + uid + "," + teachers
268                elif output.find("others")!=-1:
269                        path="uid=" + uid + "," + others
270                elif output.find("admin")!=-1:
271                        path="uid=" + uid + "," + admin
272                else:
273                        return "false"
274               
275                dic["path"]=path
276               
277                #dic["llxvars"]=llxvars
278               
279                try:
280                       
281                        tmp_ldap=ldap.initialize(llxvars("CLIENT_LDAP_URI"))
282                        dic["a"]="initialize"
283                        tmp_ldap.set_option(ldap.VERSION,ldap.VERSION3)
284                        dic["b"]="set_option"
285                        tmp_ldap.bind_s(path,password)
286                        dic["c"]="bind"
287                        self.ldap.change_password(path,new_password)
288                        dic["d"]="ldap password"
289                       
290                        if "Teachers" in path:
291                                self.pw.set_externally_modified(uid)
292                       
293                        return "true"
294                       
295                except Exception as inst:
296
297                       
298
299                        dic["exception"]=inst
300               
301                        return "false"
302               
303        #def change_own_password
304       
305       
306       
307       
308        def delete_student(self,uid,delete_data=True):
309               
310                user_info={}
311                user_info["uid"]=uid
312                user_info["profile"]="students"
313       
314                #self.unfreeze_user(uid)
315       
316       
317                if delete_data==True:
318                        homepath = self.netfiles.delete_home(user_info)
319
320                os.system("rm -rf /home/%s"%uid)
321
322                ret=self.ldap.delete_student(uid)
323               
324                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem','delete_student')
325                properties = {}
326                properties['uid'] = uid
327                properties['group_type'] = 'Students'
328                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','delete_user',[properties])
329                return ret
330               
331        #def delete_student
332               
333               
334               
335        def delete_teacher(self,uid,delete_data=True):
336
337                user_info={}
338                user_info["uid"]=uid
339                user_info["profile"]="teachers"
340
341                #self.unfreeze_user(uid)               
342
343                if delete_data==True:
344                        homepath = self.netfiles.delete_home(user_info)
345
346                os.system("rm -rf /home/%s"%uid)
347               
348                self.pw.remove_password(uid)
349                ret=self.ldap.delete_teacher(uid)
350               
351                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem','delete_teacher')
352                properties = {}
353                properties['uid'] = uid
354                properties['group_type'] = 'Teachers'
355                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','delete_user',[properties])
356
357                return ret
358        #def delete_teacher
359
360        def delete_other(self,uid,delete_data=True):
361
362                user_info={}
363                user_info["uid"]=uid
364                user_info["profile"]="others"
365               
366                self.unfreeze_user(uid)
367               
368               
369                if delete_data==True:
370                        homepath = self.netfiles.delete_home(user_info)
371
372               
373                self.pw.remove_password(uid)
374
375                ret=self.ldap.delete_other(uid)
376                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem','delete_other')
377                properties = {}
378                properties['uid'] = uid
379                properties['group_type'] = 'Others'
380                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','delete_user',[properties])
381
382                return ret
383               
384        #def delete_other
385
386        def delete_students(self,delete_data=True):
387               
388                list=self.ldap.search_user("*")
389               
390                ret_list=[]
391               
392                for item in list:
393                        if item.properties["path"].find("ou=Students")!=-1:
394                                ret=self.delete_student(item.properties["uid"],delete_data) 
395                                ret_list.append(item.properties["uid"] +":"+ret)
396                               
397                return ret_list
398                               
399                       
400               
401        #def delete_students
402       
403        def delete_teachers(self,delete_data=True):
404               
405                list=self.ldap.search_user("*")
406               
407                ret_list=[]
408               
409                for item in list:
410                        if item.properties["path"].find("ou=Teachers")!=-1:
411                                ret=self.delete_teacher(item.properties["uid"],delete_data)
412                                ret_list.append(item.properties["uid"] +":"+ret)
413
414                return ret_list
415                       
416               
417        #def delete_students
418       
419
420        def delete_all(self,delete_data=True):
421               
422                list=self.ldap.search_user("*")
423               
424                ok=True
425               
426                ret_list=[]
427               
428                for item in list:
429                        if item.properties["path"].find("ou=Teachers")!=-1:
430                                ret=self.delete_teacher(item.properties["uid"],delete_data)
431                                ret_list.append(item.properties["uid"] +":"+ret)
432                               
433                        if item.properties["path"].find("ou=Students")!=-1:
434                                ret=self.delete_student(item.properties["uid"],delete_data)
435                                ret_list.append(item.properties["uid"] +":"+ret)
436                               
437                        if item.properties["path"].find("ou=Other")!=-1:
438                                ret=self.delete_other(item.properties["uid"],delete_data)
439                                ret_list.append(item.properties["uid"] +":"+ret)
440                               
441                return ret_list
442               
443        #def delete_students
444
445        def get_students_function_list(self):
446                return students_func_list
447
448        def get_teachers_function_list(self):
449                return teachers_func_list
450               
451        def get_admin_function_list(self):
452                return admin_func_list
453               
454        def get_others_function_list(self):
455                return others_func_list
456
457        def get_student_list(self):
458               
459                list=self.ldap.search_students("*")
460               
461                return_list=[]
462               
463                for item in list:
464                        return_list.append(item.properties)
465                                                       
466                return return_list
467               
468        def get_teacher_list(self):
469               
470                list=self.ldap.search_teachers("*")
471               
472                return_list=[]
473               
474                for item in list:
475                        return_list.append(item.properties)
476                                                       
477                return return_list
478                       
479        def get_user_list(self,filter):
480
481                list=self.ldap.search_user(filter)
482
483               
484                #return self.ldap.light_search(filter)
485               
486                return_list=[]
487                for item in list:
488                        return_list.append(item.properties)
489                       
490                return return_list
491               
492
493        #def get_user_list
494       
495        def light_get_user_list(self):
496               
497                list=self.ldap.light_search()
498
499                       
500                return list
501               
502        #def light_get_user_list
503       
504        def get_available_groups(self):
505               
506                return self.ldap.get_available_groups()
507               
508        #def get_available_groups
509       
510
511        def add_to_group(self,uid,group):
512               
513                result=self.ldap.add_to_group_type(group,uid)
514
515                user_info={}
516                user_info["uid"]=uid
517               
518                path=self.ldap.get_dn(uid)
519               
520                if path.find("ou=Students")!=-1:
521                        user_info["profile"]="students"
522                if path.find("ou=Teachers")!=-1:
523                        user_info["profile"]="teachers" 
524                if path.find("ou=Other")!=-1:
525                        user_info["profile"]="others"   
526                       
527               
528
529                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('add_to_group'),{'group':{'cn':group},'user':user_info})
530                #return must be "true" (string)
531               
532                return result
533               
534        #def add_to_group
535       
536        def remove_from_group(self,uid,group):
537               
538                result=self.ldap.del_user_from_group(uid,group)
539                user_info={}
540                user_info["uid"]=uid
541               
542               
543               
544                #return must be "true" (string)
545
546                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('remove_from_group'),{'group':{'cn':group},'user':user_info})
547                return result
548               
549        #def remove_from_group
550
551
552        def change_student_personal_data(self,uid,name,surname):
553                name=unicode(name).encode("utf8")
554                surname=unicode(surname).encode("utf8")
555                result=self.ldap.change_student_name(uid,name)
556                #print result
557                result2=self.ldap.change_student_surname(uid,surname)
558                #print result2
559                if result==result2 and result=="true":
560                       
561                        # TODO
562                        # Execute hook to moodle
563
564
565                        properties = {}
566                        properties['group_type'] = 'Students'
567                        properties['uid'] = uid
568                        properties['cn'] = name
569                        properties['sn'] = surname
570                        self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','update_user',[properties])
571
572                        return result
573                else:
574                        return result + "," + result2
575               
576        #def change_personal_data
577       
578        def change_password(self,path,password,uid="",cn="",sn="",auto=False):
579               
580                password=unicode(password).encode("utf8")
581                result=self.ldap.change_password(path,password)
582               
583                #trying to obtain user uid
584                list=path.split(",")
585                uid=list[0].split("=")[1]
586               
587               
588                #return=="true"
589               
590                if uid!="" and cn!="" and sn!="":
591                        self.pw.add_password(uid,cn,sn,password)
592                       
593                if not auto:
594                        if "Teachers" in path:
595                                self.pw.set_externally_modified(uid)
596               
597                return result
598               
599        #def change_student_password
600
601        def change_student_password(self,uid,password):
602               
603                result=self.ldap.change_user_password(uid,password)
604               
605                #return=="true"
606               
607               
608                return result
609               
610        #def change_student_password
611        def freeze_user(self,uid_list):
612                self.ldap.freeze_user(uid_list)
613                return 0
614        #def freeze_user
615
616        def freeze_group(self,cn):
617                self.ldap.freeze_group(cn)
618                return 0
619        #def freeze_group
620
621        def unfreeze_user(self,uid_list):
622                self.ldap.unfreeze_user(uid_list)
623                return 0
624        #def unfreeze_user
625
626        def unfreeze_group(self,cn):
627                self.ldap.unfreeze_group(cn)
628                return 0
629        #def unfreeze_group
630       
631        def add_teacher_to_admins(self,uid):
632               
633                result=self.ldap.add_teacher_to_admins(uid)
634               
635                return result
636               
637        #def add_teacher_to_admins
638       
639        def del_teacher_from_admins(self,uid):
640               
641                result=self.ldap.del_teacher_from_admins(uid)
642                return result
643               
644        #def de_teacher_from_admins
645       
646       
647        def change_group_description(self,gid,description):
648               
649                description=unicode(description).encode("utf8")
650                result=self.ldap.change_group_description(gid,description)
651               
652                return result
653               
654        #def change_group_description
655       
656        def delete_group(self,group_name):
657
658                #self.unfreeze_group(gid)
659                result=self.ldap.delete_group(group_name)
660                try:
661                        self.netfiles.remove_group_folder(group_name)
662                except Exception as e:
663                        print(e)
664               
665                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('delete_group'),{'group':{'cn':group_name}})
666                return result
667               
668        #def delete_group
669       
670       
671        def add_group(self,properties):
672                properties["description"]=unicode(properties["description"]).encode("utf8")
673                result=self.ldap.add_group(properties)
674               
675                try:
676                        self.create_group_folder(properties["cn"])
677                except Exception as e:
678                        print(e)
679               
680                try:
681                        self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('add_group'),{'group':properties})
682                except Exception as e:
683                        print(e)
684                return result
685               
686        #def add_group
687       
688        def get_students_passwords(self):
689               
690                list = self.ldap.get_students_passwords()
691
692                return self.quicksort(list)
693               
694        #def get_students_passwords
695       
696        def get_teachers_passwords(self):
697               
698                ret=self.light_get_user_list()
699               
700                tmp_teachers={}
701
702                for item in ret:
703                       
704                        if item[-1]=="teachers":
705                                teacher={}
706                                teacher["uid"]=item[1]
707                                teacher["cn"]=item[3]
708                                teacher["sn"]=item[4]
709                                teacher["passwd"]=" #! UNKNOWN PASSWORD !# "   
710                                tmp_teachers[item[1]]=teacher
711                               
712                               
713                ret2=self.quicksort(self.pw.get_passwords())
714
715                final_ret=[]
716
717                for item in ret2:
718                        if item["uid"] in tmp_teachers:
719                                tmp_teachers[item["uid"]]["passwd"]=item["passwd"]
720                       
721
722                for item in tmp_teachers:
723                        final_ret.append(tmp_teachers[item])
724                       
725               
726                return final_ret
727               
728        #def get_teachers_passwords
729       
730        def get_all_passwords(self,force_teachers=False):
731                list=self.ldap.get_students_passwords()
732                if not force_teachers:
733                        list2=self.pw.get_passwords()
734                else:
735                        list2=self.ldap.get_teachers_passwords()
736                for item in list2:
737                        list.append(item)
738                return self.quicksort(list)
739               
740        #def get_all_passwords
741       
742        def quicksort (self,lista): 
743                self.sort_quicksort(lista,0,len(lista)-1) 
744                return lista
745       
746        #def quicksort
747       
748        def sort_quicksort (self,lista,izdo,dcho) : 
749                if izdo<dcho : 
750                        pivote=lista[(izdo+dcho)/2] 
751                        i,d=izdo,dcho
752                        while i<=d : 
753                                while lista[i]['sn'].lower()<pivote['sn'].lower() : i+=1 
754                                while lista[d]['sn'].lower()>pivote['sn'].lower() : d-=1 
755                                if i<=d : 
756                                        lista[i],lista[d]=lista[d],lista[i] 
757                                        i+=1 
758                                        d-=1 
759                        if izdo<d : self.sort_quicksort(lista,izdo,d) 
760                        if i<dcho : self.sort_quicksort(lista,i,dcho) 
761                return lista
762        #def sort_quicksort
763       
764       
765        def generic_student_to_itaca(self,uid,nia):
766               
767                return self.ldap.generic_student_to_itaca(uid,nia)
768               
769        #def generic_student_to_itaca
770       
771        def generic_teacher_to_itaca(self,uid,nif):
772               
773                return self.ldap.generic_teacher_to_itaca(uid,nif)
774               
775        #def generic_teachers_to_itaca
776       
777        def send_xml_to_server(self,data64,file_name,passwd=""):
778                server_path="/tmp/" + file_name
779                try:
780                        ret=self.file_operations.send_file_to_server(data64,server_path)
781                        if self.mime.file(server_path).split(";")[0]=="application/xml":
782                                pass
783                        elif self.mime.file(server_path).split(";")[0]=="application/octet-stream":
784                                if passwd=="":
785                                        return "false:xml_encrypted"
786                                else:
787                                        p=subprocess.Popen(["openssl","enc","-des","-d","-k",passwd,"-in",server_path,"-out",server_path+".xml"],stderr=subprocess.PIPE)
788                                        output=p.communicate()[1]
789                                        if output!=None:
790                                                if "bad decrypt" in output:
791                                                        return "false:xml_bad_password"
792
793                                        server_path=server_path+".xml"
794                                        if self.mime.file(server_path).split(";")[0]=="application/xml":
795                                                pass
796                                        else:
797                                                return "false:invalid_xml"
798                                               
799                       
800                except Exception as e:
801                        print e
802                        return "false:send_error"
803                if ret==1:
804                        try:
805                                ret=self.gescen_set_path(server_path)
806                                if ret==True:
807                                        return "true"
808                                elif ret==False:
809                                        return "false:xml_error"
810                                elif ret=="false:xml_encrypted":
811                                        return ret
812                                else:
813                                        return "false:unknown_error"
814                        except:
815                                return "false:xml_error"
816                else:
817                        return "false:send_error"
818               
819               
820        #def send_xml_to_server
821       
822       
823        def gescen_info(self):
824                return self.itaca.get_info()
825        #def gescen_info
826       
827        def gescen_set_path(self,path):
828                return self.itaca.set_path(path)
829        #def gescen_info
830       
831        def gescen_load(self):
832                return self.itaca.load_file()
833        #def gescen_info
834
835        def gescen_groups(self):
836                return self.itaca.get_groups()
837        #def gescen_group
838
839        def gescen_partial(self,group_list):
840                #print "partial"
841                #print group_list
842                self.sharefunctions['generate_uid'] = generate_uid
843                users_added = self.itaca.partial_import(group_list)
844                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('gescen_partial'),{})
845                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','add_user',users_added)
846                return 'true'
847
848        #def gescen_partial
849
850        def gescen_full(self):
851
852                try:
853                        self.sharefunctions['generate_uid'] = generate_uid
854                except Exception as e:
855                        print e
856                        raise e
857
858                ret,users_added=self.itaca.full_import()
859                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/golem',('gescen_full'),{})
860                self.peter_pan.execute_python_dir('/usr/share/n4d/hooks/openmeetings','add_user',users_added)
861                return ret
862        #def gescen_full
863       
864        def empty_students(self,generic=None):
865                list=self.ldap.search_user("*")
866               
867                ret_list=[]
868               
869                for item in list:
870                        if item.properties["path"].find("ou=Students")!=-1:
871                                ret=self.empty_home(item.properties)
872                                ret_list.append(item.properties["uid"] +":"+ret)
873                return ret_list
874        #def empty_students
875       
876        def empty_teachers(self,generic=None):
877                list=self.ldap.search_user("*")
878               
879                ret_list=[]
880               
881                for item in list:
882                        if item.properties["path"].find("ou=Teachers")!=-1:
883                                ret=self.empty_home(item.properties)
884                                ret_list.append(item.properties["uid"] +":"+ret)
885                return ret_list
886        #def empty_teachers
887       
888        def empty_others(self,generic=None):
889                list=self.ldap.search_user("*")
890               
891                ret_list=[]
892               
893                for item in list:
894                        if item.properties["path"].find("ou=Other")!=-1:
895                                ret=self.empty_home(item.properties)
896                                ret_list.append(item.properties["uid"] +":"+ret)
897                return ret_list
898        #def empty_others
899       
900        def empty_all(self):
901               
902                ret_list=[]
903                ret_list.extend(self.empty_students(True))
904                ret_list.extend(self.empty_teachers(True))
905                ret_list.extend(self.empty_others(True))
906                return ret_list
907               
908        #def empty_all
909               
910               
911       
912        def empty_home(self,user_info):
913                try:
914                        self.netfiles.delete_home(user_info)
915                        self.netfiles.create_home(user_info)
916                        return "true"
917                except:
918                        return "false"
919        #def empty_home
920
921        def get_frozen_users(self):
922                return self.ldap.get_frozen_users()
923        #def get_frozen_users
924
925        def get_frozen_groups(self):
926                return self.ldap.get_frozen_groups()
927        #def get_frozen_groups
928       
929        def is_frozen_user(self,user):
930                return self.ldap.is_frozen_user(user)
931               
932        def exist_home_or_create(self,user):
933                return self.netfiles.exist_home_or_create(user)
934               
935
936        def create_group_folder(self,group_name):
937               
938                return self.netfiles.create_group_folder(group_name)
939               
940               
941        #def create_group_folder
942       
943        def restore_groups_folders(self):
944                ret=[]
945                try:
946                       
947                        for item in self.get_available_groups():
948                                try:
949                                        id=self.create_group_folder(item["cn"][0])
950                                        ret.append((item["cn"][0],id))
951                                except Exception as ex:
952                                        ret.append((item["cn"][0],str(ex)))
953                       
954                except Exception as e:
955                        ret.append(str(e))
956                       
957                return ret
958               
959        #def restore_group_folders
960       
961        def full_search(self):
962               
963                return self.ldap.full_search("*")
964               
965        #def full_search
966       
967       
968        def export_llum_info(self):
969               
970                try:
971               
972                        user_list=self.get_user_list("*")
973                        pwd_list=self.get_all_passwords(True)
974                        groups=self.get_available_groups()
975                       
976                        exported_groups={}
977                        exported_users={}
978               
979                        for item in groups:
980                               
981                                exported_groups[item["cn"][0]]={}
982                                if item.has_key("memberUid"):
983                                        exported_groups[item["cn"][0]]["members"]=item["memberUid"]
984                                else:
985                                        exported_groups[item["cn"][0]]["members"]=[]
986                                exported_groups[item["cn"][0]]["description"]=item["description"][0]
987                               
988                        for item in user_list:
989                               
990                                if item["profile"]=="teachers":
991                                        profile="Teachers"
992                                elif item["profile"]=="students":
993                                        profile="Students"
994                                else:
995                                        continue
996                               
997                                exported_users[item["uid"]]={}
998                                exported_users[item["uid"]]["profile"]=profile
999                                exported_users[item["uid"]]["cn"]=item["cn"]
1000                                exported_users[item["uid"]]["sn"]=item["sn"]
1001                                exported_users[item["uid"]]["groups"]=item["groups"]
1002                                exported_users[item["uid"]]["is_admin"]=item["is_admin"]
1003                       
1004
1005                        for item in pwd_list:
1006                                if item["uid"] in exported_users:
1007                                        exported_users[item["uid"]]["userPassword"]=item["passwd"]
1008                                        exported_users[item["uid"]]["sambaNTPassword"]=item["sambaNTPassword"]
1009                                        exported_users[item["uid"]]["sambaLMPassword"]=item["sambaLMPassword"]
1010                               
1011                        exported={}
1012                        exported["groups"]=exported_groups
1013                        exported["users"]=exported_users
1014
1015                        return [True,exported]
1016               
1017                except Exception as e:
1018
1019                        return [False,str(e)]
1020               
1021                                               
1022               
1023        #def export_llum_info
1024       
1025        def import_llum_info(self,exported_info):
1026               
1027                try:
1028                        for group in exported_info["groups"]:
1029
1030                                properties={}
1031                                properties["description"]=exported_info["groups"][group]["description"]
1032                                properties["cn"]=group
1033                                self.add_group(properties)
1034                               
1035                        for user in exported_info["users"]:
1036                               
1037                                properties={}
1038                                properties["uid"]=user
1039                                properties["cn"]=exported_info["users"][user]["cn"]
1040                                properties["sn"]=exported_info["users"][user]["sn"]
1041                                properties["userPassword"]=exported_info["users"][user]["userPassword"]
1042                                properties["sambaLMPassword"]=exported_info["users"][user]["sambaLMPassword"]
1043                                properties["sambaNTPassword"]=exported_info["users"][user]["sambaNTPassword"]
1044                                profile=exported_info["users"][user]["profile"]
1045                               
1046                                self.add_user(profile,properties)
1047                               
1048                               
1049                        for group in exported_info["groups"]:
1050                       
1051                                for user in exported_info["groups"][group]["members"]:
1052                                        self.add_to_group(user,group)
1053                                       
1054                        for user in exported_info["users"]:
1055                               
1056                                if exported_info["users"][user]["is_admin"]:
1057                                        self.add_teacher_to_admins(user)
1058                       
1059                        return[True,]
1060                except Exception as e:
1061                       
1062                        return [False,str(e)]
1063               
1064        #def import_llum_info
1065       
1066        def regenerate_net_files(self,mode=0):
1067               
1068                try:
1069                        ret=self.light_get_user_list()
1070                        users=[]
1071                        for item in ret:
1072                                user={}
1073                                user["profile"]=item[5]
1074                                user["uid"]=item[1]
1075                                user["uidNumber"]=item[2]
1076                                users.append(user)
1077                       
1078                        for user in users:
1079                                try:
1080                                        self.netfiles.exist_home_or_create(user,mode)
1081                                except:
1082                                        pass
1083                               
1084                        try:
1085                               
1086                                self.restore_groups_folders(self)
1087                        except:
1088                                pass
1089                       
1090                except:
1091                        pass
1092               
1093        #def regenerate_net_files
1094       
1095        def is_roadmin_available(self):
1096               
1097                try:
1098                        return self.ldap.custom_search("cn=roadmin,"+llxvars("LDAP_BASE_DN"))["status"]
1099                except:
1100                        return False
1101       
1102        #def is_roadmin_avaiable
1103       
1104
1105#class Golem
1106
1107
1108if __name__=="__main__":
1109       
1110        golem=Golem()
Note: See TracBrowser for help on using the repository browser.