Produits Entr'ouvert » Hobo

        provisionning.start()

    def process_exception(self, request, exception):

    def process_response(self, request, response):

        return response

from authentic2.a2_rbac.models import RoleAttribute

from authentic2.models import AttributeValue

    threads = set()

    def __init__(self):

    def start(self):

            return

        for instance in args:

            return

        for instance in args:

    def resolve_ou(self, instances, ous):

        for instance in instances:

    def notify_users(self, ous, users, mode='provision'):

        if mode == 'provision':

                     .select_related('ou').prefetch_related('attribute_values__attribute'))

        else:

            self.resolve_ou(users, ous)

            # Find roles giving a superuser attribute

            # If there is any role of this kind, we do one provisionning message for each user and

            # each service.

                                     .parents(include_self=True)

                                     .filter(attributes__name='is_superuser')

                                     .exists())

                         .prefetch_related('attributes').distinct())

            roles = dict((r.id, r) for r in all_roles)

            user_roles = {}

            parents = {}

                parents.setdefault(rp.child.id, []).append(rp.parent.id)

            for u_id, r_id in Through.objects.filter(role__members__in=users).values_list('user_id',

                                                                                      'role_id'):

                user_roles.setdefault(u_id, set()).add(roles[r_id])

                for ou, users in ous.iteritems():

                    for service, audience in self.get_audience(ou):

                        for user in users:

                            notify_agents({

                                '@type': 'provision',

                                'issuer': issuer,

                    audience = [a for service, a in self.get_audience(ou)]

                    if not audience:

                        continue

                                     u', '.join(map(unicode, users)), u', '.join(audience))

                    notify_agents({

                        '@type': 'provision',

                        }

                    })

        elif users:

                        for s, audience in self.get_audience(ou)]

                             u', '.join(audience))

            notify_agents({

                '@type': 'deprovision',

                ]

            audience = [entity_id for service, entity_id in self.get_audience(ou)]

            notify_agents({

                '@type': mode,

                'audience': audience,

            sent_roles = set(ou_roles) | global_roles

            helper(ou, sent_roles)

        if (not hasattr(connection, 'tenant') or not connection.tenant or not

                hasattr(connection.tenant, 'domain_url')):

            return

        if not getattr(settings, 'HOBO_ROLE_EXPORT', True):

            return

            return

        t.start()

        self.threads.add(t)

    def do_provision(self, saved, deleted, thread=None):

        try:

        except Exception:

            # last step, clear everything

        finally:

            self.threads.discard(threading.current_thread())

        self.start()

    def __exit__(self, exc_type, exc_value, exc_tb):

    def get_audience(self, ou):

        if ou:

        return urljoin(base_url, reverse('a2-idp-saml-metadata'))

    def pre_save(self, sender, instance, raw, using, update_fields, **kwargs):

        # we skip new instances

        if not instance.pk:

            return

            return

        # ignore last_login update on login

            return

        if isinstance(instance, RoleAttribute):

            instance = instance.role

        elif isinstance(instance, AttributeValue):

                return

            instance = instance.owner

    def post_save(self, sender, instance, created, raw, using, update_fields, **kwargs):

        # during post_save we only handle new instances

            return

        if not created:

            return

            return

        if isinstance(instance, RoleAttribute):

            instance = instance.role

        elif isinstance(instance, AttributeValue):

                return

            instance = instance.owner

    def pre_delete(self, sender, instance, using, **kwargs):

        elif isinstance(instance, RoleAttribute):

            instance = instance.role

        elif isinstance(instance, AttributeValue):

                return

            instance = instance.owner

    def m2m_changed(self, sender, instance, action, reverse, model, pk_set, using, **kwargs):

        if action != 'pre_clear' and action.startswith('pre_'):

            return

            # on a clear, pk_set is None

            for other_instance in model.objects.filter(pk__in=pk_set or []):

            if action == 'pre_clear':

                # when the action is pre_clear we need to lookup the current value of the members

                # relation, to re-provision all previously enroled users.

                if not reverse:

                    for other_instance in instance.members.all():