Produits Entr'ouvert » Authentic 2

class OrganizationalUnitManager(AbstractBaseManager):

class RoleManager(BaseRoleManager):

    no_email_validation = serializers.BooleanField(required=False)

    return_url = serializers.URLField(required=False, allow_blank=True)

        request = self.context.get('request')

        if request:

            perm = 'custom_user.add_user'

            if ou:

            else:

                authorized = request.user.has_perm(perm)

            if not authorized:

        User = get_user_model()

        if ou:

            if app_settings.A2_EMAIL_IS_UNIQUE or app_settings.A2_REGISTRATION_EMAIL_IS_UNIQUE:

                    raise serializers.ValidationError(_('Email is required'))

                    raise serializers.ValidationError(_('Account already exists'))

            if ou.email_is_unique:

                    raise serializers.ValidationError(_('Email is required in this ou'))

                    raise serializers.ValidationError(_('Account already exists in this ou'))

            if app_settings.A2_USERNAME_IS_UNIQUE or app_settings.A2_REGISTRATION_USERNAME_IS_UNIQUE:

                    raise serializers.ValidationError(_('Username is required'))

                    raise serializers.ValidationError(_('Account already exists'))

            if ou.username_is_unique:

                    raise serializers.ValidationError(_('Username is required in this ou'))

                    raise serializers.ValidationError(_('Account already exists in this ou'))

class RpcMixin:

    old_password = serializers.CharField(required=True, allow_null=True)

    new_password = serializers.CharField(required=True, allow_null=True)

        User = get_user_model()

        try:

            self.user = qs.get()

        except User.DoesNotExist:

            raise serializers.ValidationError('no user found')

        except MultipleObjectsReturned:

            raise serializers.ValidationError('more than one user have this email')

            raise serializers.ValidationError('old_password is invalid')

class PasswordChange(BaseRpcView):

            instance.save()

        return instance

        User = get_user_model()

        qs = User.objects.all()

        if self.instance:

            ou = self.instance.ou

        get_or_create_fields = self.context['view'].request.GET.getlist('get_or_create')

        update_or_create_fields = self.context['view'].request.GET.getlist('update_or_create')

        if (

            'email' not in get_or_create_fields

            and 'email' not in update_or_create_fields

        ):

                already_used = True

                already_used = True

        errors = {}

        if already_used:

            errors['email'] = 'email already used'

            errors['password'] = 'conflict with provided hashed_password'

            try:

            except ValueError:

                errors['hashed_password'] = "unknown hash format"

            else:

                try:

                except Exception:

                    errors['hashed_password'] = "hash format error"

        if errors:

            raise serializers.ValidationError(errors)

    class Meta:

        model = get_user_model()

            return new_qs

        return qs

        # filter users authorized for a specified service

        if 'service-slug' in self.request.GET:

            service_slug = self.request.GET['service-slug']

            )

            if service:

                if service.authorized_roles.all():

            else:

    def update(self, request, *args, **kwargs):

        kwargs['partial'] = True

class ServiceOUField(serializers.ListField):

        if not len(data) == 2:

            raise ValidationError('This field should be a service slug and an OU slug separated by space.')

        return super().to_internal_value(data)

    def create_superuser(self, username, email, password, **extra_fields):

        return self._create_user(username, email, password, True, True, **extra_fields)

class EventTypeWithService(EventTypeDefinition):

    @classmethod

        if service:

            if not data:

                data = {}

            if not references:

                references = []

            references = [service] + references

    @classmethod

    def get_service_name(cls, event):

    label = _('user activation')

    @classmethod

    def record(cls, target_user, user=None, session=None, origin=None, reason=None):

        data = {'origin': origin, 'reason': reason}

        super().record(user=user, session=session, references=[target_user], data=data)

    label = _('user deactivation')

    @classmethod

    def record(cls, target_user, user=None, session=None, origin=None, reason=None):

        data = {'reason': reason, 'origin': origin}

        super().record(user=user, session=session, references=[target_user], data=data)

                yield from super().lexem_queries('email:' + lexem)

                yield from super().lexem_queries('username:' + lexem)

        if fullname:

            users = User.objects.find_duplicates(fullname=fullname)

            return self.query_for_users(users)

    def clean(self, value):

        raise NotImplementedError

        return ', '.join(str(v) for v in value.all())

    def popNamespace(self):

        self.__ns = self.__old_ns.pop()

        tag = '{%s}%s' % (self.__ns, tag)

        self.__opened.append(tag)

    def simple_content(self, tag, data):

        self.start(tag, {})