Esempio n. 1
0
def get_users(request, year=None, month=None, day=None):
    dap_work = LdapWork(settings.LDAP)

    if year and month and day:
        users = User.objects.filter(date_joined__year=year, date_joined__month=month, date_joined__day=day ).order_by('-date_joined')
    if year and month and  not day:
        users = User.objects.filter(date_joined__year=year, date_joined__month=month).order_by('-date_joined')
    if year and not month and  not day:
        users = User.objects.filter(date_joined__year=year).order_by('-date_joined')
    if not year and not month and  not day:
        users = User.objects.all().order_by('-date_joined')

    user_maps = []
    for user in users:
        user_map = {}
        ldap_user = dap_work.get_users_by_attr(username=user.username)
        if ldap_user:
            user_map['description'] = ldap_user[0].description
            user_map['false'] = True
        else:
            user_map['new'] = True

        user_map['username'] = user.username
        user_map['date_joined'] = user.date_joined

        user_maps.append(user_map)
    return direct_to_template(request, 'ldaccounts/users.html', {
        'users': user_maps
    })
Esempio n. 2
0
def ldap_org_search(district='', code=''):
    try:
        ldap_connection = LdapConnection(settings.LDAP)
        ldap_work = LdapWork(ldap_connection)
    except LdapWorkException as e:
        sys.stderr.write('Error of connection to LDAP server: ' + e.message)
        return None
    ldap_orgs = ldap_work.get_org_by_attr(district=district, code=code)
    return ldap_orgs
Esempio n. 3
0
    def clean_username(self):
        import re
        format = re.compile(r"^[a-zA-z0-9]+$")
        if re.match(format,self.cleaned_data["username"]) == None:
            raise forms.ValidationError(u"Логин может содержать только латинские символы")

        username = self.cleaned_data["username"]
        ldap_users = []
        try:
            lc = LdapConnection(settings.LDAP)
            lw = LdapWork(lc)
            ldap_users = lw.get_users_by_attr(username=username)
        except LdapWorkException as e:
            import sys

        if len(ldap_users):
            raise forms.ValidationError(_("A user with that username already exists."))
        try:
            User.objects.get(username=username)
        except User.DoesNotExist:
            return username

        raise forms.ValidationError(_("A user with that username already exists."))
Esempio n. 4
0
    def get_or_create_user(self, username, password):
        """
            Функция принимает имя пользователя и пароль. Если на LDAP сервере существует
        подходящий пользователь - проверяется его наличие в локальной базе, если в 
        базе его не оказалось, то пользователь создается в локальной базе(синхронизация 
        с LDAP пользователем) и возвращается как User, попутно присваивая ему группу 
        для доступа к функциям сайта.
            Если пользователя не существует в LDAP, но существует в локальной базе,
        проверяем его на принадлежность к супер админу, если супер админ, то логиними
        если не супер админ - удаляем.
        """

        #Устанавливаем соединение с LDAP базой



        try:
            ldap_connection = LdapConnection(settings.LDAP)
            ldap_work = LdapWork(ldap_connection)
        except LdapWorkException as e:
            sys.stderr.write('Error of connection to LDAP server: ' + e.message)
            if settings.LDAP_USERS_SYNC:
                return None
        except Exception:
            sys.stderr.write('Error of connection to LDAP server: ' + e.message)
            if settings.LDAP_USERS_SYNC:
                return None

            #Филтр запроса на получение объета пользователя
            #filter = '(&(uid=%s)(objectClass=RUSLANperson)(userPassword=%s))' % (username, password)
            #аттрибуты, которые будут извлечены для обработки
            #attrs = ['uid','sn','memberOf','userPassword','mail','telephoneNumber']

            #ldap_results = ldap_connection.search_s( settings.LDAP_BASE_DN, ldap.SCOPE_SUBTREE, filter, attrs )
        ldap_users = ldap_work.get_users_by_attr(username=username, password=password)

        #если пользователь не существет в LDAP
        #проверяем, существует ли он в локальной базе
        #если да, то в случае, если пользователь не админ, удаляем его
        if len(ldap_users) == 0: #пользователь не найден
            try:
                user = User.objects.get(username=username)
            except User.DoesNotExist:
                return None
            else:
                if user.is_superuser == False and settings.LDAP_USERS_SYNC == False:
                    user.delete()
                    return None


                #Если пользователь прошел проверку в LDAP, пытаемся найти его в локальной базе
                #В случае его отсутвия создадим его
        try:
            user = User.objects.get(username=username)

        except User.DoesNotExist:
        #извлекаем информацию о пользователе
            ldap_user = ldap_users[0]
#            orgs =  ldap_user.dn[1:-2]
#
#            for org in orgs:
#                print 'orororor',org
#
#            ldap_groups = []
#            print 'orgs',orgs
#            for org in orgs:
#                print 'org',org
#                ldap_orgs = ldap_work.get_org_by_attr(display_name=org)
#                if ldap_orgs:
#                    ldap_groups += ldap_orgs.member_of
                    
#            print ldap_groups
            #print ldap_user.string_dn
            
            print 'member_of', ldap_user.member_of
            
            #если пользователь из ветки 'Пользователи КСОБ или он не состоит в группах,
            #то ему присваевается группа users
            user = User(username=ldap_user.uid, email=ldap_user.email)
            user.is_superuser = False
            user.set_password(password)
            if 'Пользователи КСОБ' in ldap_user.dn or len(ldap_user.member_of) == 0:
                try:
                    group = Group.objects.get(name='users')
                except Group.DoesNotExist:
                    group = Group(name='users')
                    group.save()
                if group:
                    user.is_staff = False
                    user.save()
                    user.groups.add(group)
                    return user

            else: #тогда пользователь библиотеки
                if len(ldap_user.member_of):
                    groups = []
                    for group_name in ldap_user.member_of:

                        try:
                            group = Group.objects.get(name=group_name)
                            groups.append(group)
                        except Group.DoesNotExist:
                            group = Group(name=group_name)
                            group.save()
                            groups.append(group)
                    user.is_staff = True
                    user.save()
                    for group in groups:
                        user.groups.add(group)
                    user.save()
                    return user
                raise Exception("Can't create group")

            return None