Produits Entr'ouvert » Authentic 2

    readonly_fields = ('uuid',)

    prepopulated_fields = {"slug": ("name",)}

    filter_horizontal = ('members', 'permissions')

    list_select_related = True

    list_filter = ['ou', 'service']

    inlines = [RoleAttributeInline]

from . import managers, fields

class OrganizationalUnit(OrganizationalUnitAbstractBase):

    RESET_LINK_POLICY = 0

            'validate_emails': self.validate_emails

        }

OrganizationalUnit._meta.natural_key = [['uuid'], ['slug'], ['name']]

]

class RoleParenting(RoleParentingAbstractBase):

    class Meta(RoleParentingAbstractBase.Meta):

        verbose_name = _('role parenting relation')

        verbose_name_plural = _('role parenting relations')

class RoleAttribute(models.Model):

    KINDS = (

        )

    readonly_fields = ('uuid',)

    list_filter = UserAdmin.list_filter + (UserRealmListFilter,ExternalUserListFilter)

    def get_fieldsets(self, request, obj=None):

        fieldsets = deepcopy(super(AuthenticUserAdmin, self).get_fieldsets(request, obj))

from django.db import models

from django.conf import settings

from . import util

class ClientCertificate(models.Model):

    serial = models.CharField(max_length=255, blank=True)

    subject_dn = models.CharField(max_length=255)

    cert = models.TextField()

    user = models.ForeignKey(settings.AUTH_USER_MODEL)

        return self.subject_dn

    def explode_subject_dn(self):

        return IsVerified(obj)

class User(AbstractBaseUser, PermissionMixin):

    """

    An abstract base class implementing a fully featured User model with

            'members', queryset=self.__class__.objects.filter(pk=self.pk), to_attr='member'))

        return qs

        human_name = self.username or self.email or self.get_full_name()

        short_id = self.uuid[:6]

        return u'%s (%s)' % (human_name, short_id)

        verbose_name = _('user to delete')

        verbose_name_plural = _('users to delete')

class UserExternalId(models.Model):

    user = models.ForeignKey(settings.AUTH_USER_MODEL,

            verbose_name=_('user'))

    updated = models.DateTimeField(auto_now=True,

            verbose_name=_('last update date'))

        return u'{0} is {1} on {2}'.format(

                self.user, self.external_id, self.source)

        verbose_name = _('user external id')

        verbose_name_plural = _('user external ids')

class AuthenticationEvent(models.Model):

    '''Record authentication events whatever the source'''

    when = models.DateTimeField(auto_now=True,

        verbose_name = _('authentication log')

        verbose_name_plural = _('authentication logs')

        return _('Authentication of %(who)s by %(how)s at %(when)s') % \

            self.__dict__

        verbose_name_plural = _('logout URL')

class Attribute(models.Model):

    label = models.CharField(verbose_name=_('label'), max_length=63,

            unique=True)

    def natural_key(self):

        return (self.name,)

        return self.label

    class Meta:

        )

class PasswordReset(models.Model):

    user = models.OneToOneField(settings.AUTH_USER_MODEL,

            verbose_name=_('user'))

        verbose_name = _('password reset')

        verbose_name_plural = _('password reset')

        return six.text_type(self.user)

class Service(models.Model):

    name = models.CharField(

        verbose_name=_('name'),

    def natural_key(self):

        return [self.ou and self.ou.natural_key(), self.slug]

        return self.name

    def __repr__(self):

import datetime as dt

from django.db import models

__all__ = ('Nonce',)

        now = now or timezone.now()

        self.filter(not_on_or_after__lt=now).delete()

class Nonce(models.Model):

    value = models.CharField(max_length=_NONCE_LENGTH_CONSTANT)

    context = models.CharField(max_length=_NONCE_LENGTH_CONSTANT, blank=True,

    objects  = NonceManager()

        return self.value

)

class SPOptionsIdPPolicy(models.Model):

    '''

        Policies configured as a SAML2 identity provider.

        verbose_name = _('service provider options policy')

        verbose_name_plural = _('service provider options policies')

        return self.name

class SAMLAttribute(models.Model):

    ATTRIBUTE_NAME_FORMATS = (

            ('basic', 'Basic'),

        for text_value in normalize_attribute_values(values):

            yield (name, name_format, friendly_name, text_value)

        return u'%s %s %s' % (self.name, self.name_format_uri(), self.attribute_name)

    def natural_key(self):

            'friendly_name', 'attribute_name'),)

class LibertyProvider(Service):

    entity_id = models.URLField(max_length=256, unique=True,

            verbose_name=_('Entity ID'))

    objects = managers.LibertyProviderManager()

        return self.name

    def save(self, *args, **kwargs):

# TODO: The IdP must look to the preferred binding order for sso in the SP metadata (AssertionConsumerService)

# expect if the protocol for response is defined in the request (ProtocolBinding attribute)

class LibertyServiceProvider(models.Model):

    liberty_provider = models.OneToOneField(LibertyProvider,

            primary_key = True, related_name = 'service_provider')

    def natural_key(self):

        return (self.liberty_provider.slug,)

        return six.text_type(self.liberty_provider)

    class Meta:

# XXX: for retrocompatibility

federation_delete = managers.federation_delete

class LibertyFederation(models.Model):

    """Store a federation, i.e. an identifier shared with another provider, be

       it IdP or SP"""

        verbose_name = _("SAML federation")

        verbose_name_plural = _("SAML federations")

        return self.name_id_content

class LibertySession(models.Model):

    """Store the link between a Django session and a SAML session"""

    django_session_key = models.CharField(max_length = 128)

        qs = qs.filter(Q(name_id_sp_name_qualifier__isnull=True)|Q(name_id_sp_name_qualifier=provider_id))

        return qs

        return '<LibertySession %s>' % self.__dict__

    class Meta:

        verbose_name = _("SAML session")

        verbose_name_plural = _("SAML sessions")

class KeyValue(models.Model):

    key = models.CharField(max_length=128, primary_key=True)

    value = PickledObjectField()

    objects = a2_managers.ExpireManager()

        return self.key

    class Meta:

import json

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.conf import settings

from django.core.exceptions import ValidationError

        raise ValidationError(_('Invalid JWKSet: %s') % e)

class OIDCProvider(models.Model):

    STRATEGY_CREATE = 'create'

    STRATEGY_FIND_UUID = 'find-uuid'

            return JWK(kty='oct', k=base64url_encode(self.client_secret.encode('utf-8')))

        return None

        return self.name

    def authorization_claims_parameter(self):

        return '<OIDCProvider %r>' % self.issuer

class OIDCClaimMapping(models.Model):

    NOT_VERIFIED = 0

    VERIFIED_CLAIM = 1

    def natural_key(self):

        return (self.claim, self.attribute, self.verified, self.required)

        s = u'{0} -> {1}'.format(self.claim, self.attribute)

        if self.verified:

            s += u', verified'

            self.verified, self.required)

class OIDCAccount(models.Model):

    created = models.DateTimeField(

        verbose_name=_('created'),

        max_length=256,

        unique=True)

        return u'{0} on {1} linked to {2}'.format(self.sub, self.provider and self.provider.issuer,

                                                  self.user)

from django.db import models

from django.utils.translation import ugettext_lazy as _

from django.utils.timezone import now

from django.core.validators import URLValidator

url_validator = URLValidator(schemes=['http', 'https', 'ftp', 'ftps', 'imap', 'imaps', 'sieve', 'smtp', 'smtps', 'ssh'])

class Service(LogoutUrlAbstract, Service):

    urls = models.TextField(max_length=128,

            verbose_name=_('urls'))

            wanted.add(attribute.attribute_name)

        return list(wanted)

        return self.name

    class Meta:

        verbose_name_plural = _('services')

class Attribute(models.Model):

    service = models.ForeignKey(Service, verbose_name=_('service'))

    slug    = models.SlugField(verbose_name=_('slug'))

            verbose_name=_('enabled'),

            default=True)

        return u'%s <- %s' % (self.slug, self.attribute_name)

    class Meta:

def make_uuid():

    return utils.make_id(constants.SERVICE_TICKET_PREFIX)

class Ticket(models.Model):

    '''Session ticket with a CAS 1.0 or 2.0 consumer'''

    objects = managers.TicketManager()

        return self.ticket_id

    def valid(self):

                    OrganizationalUnit, 'oidc_authorizations')

class OIDCClaim(models.Model):

    client = models.ForeignKey(

        to=OIDCClient, verbose_name=_('client'))

        max_length=128, blank=True,

        verbose_name=_('attribute scopes'))

        return u'%s - %s - %s' % (self.name, self.value, self.scopes)

    def get_scopes(self):

from . import utils, constants, managers, backends

class AbstractBase(models.Model):

    '''Abstract base model for all models having a name and uuid and a

       slug

    objects = managers.AbstractBaseManager()

        return self.name

    def __repr__(self):

        swappable = constants.RBAC_OU_MODEL_SETTING

class Operation(models.Model):

    name = models.CharField(

        max_length=128,

    def natural_key(self):

        return [self.slug]

        return six.text_type(_(self.name))

    def export_json(self):

Operation._meta.natural_key = ['slug']

class PermissionAbstractBase(models.Model):

    operation = models.ForeignKey(

        to=Operation,

            "target": self.target.natural_key_json()

        }

        ct = ContentType.objects.get_for_id(self.target_ct_id)

        ct_ct = ContentType.objects.get_for_model(ContentType)

        if ct == ct_ct: