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

Last change on this file since 7593 was 7593, checked in by hectorgh, 3 years ago

various fixes. Read changelog

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