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

Last change on this file since 6719 was 6719, checked in by hectorgh, 20 months ago

Fixing password db encoding

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