Produits Entr'ouvert » Hobo

import json

import threading

import copy

import logging

from django.db import connection

from django.core.urlresolvers import reverse

from django.conf import settings

from django_rbac.utils import get_role_model, get_ou_model, get_role_parenting_model

from hobo.agent.common import notify_agents

class Provisionning(threading.local):

    __slots__ = ['threads']

    def __init__(self):

        self.stack = []

    def start(self):

        def is_forbidden_technical_role(role):

            return role.slug.startswith('_') and not role.slug.startswith(tuple(allowed_technical_roles_prefixes))

        if mode == 'provision':

            def user_to_json(ou, service, user, user_roles):

            for rp in RoleParenting.objects.filter(child__in=all_roles):

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

            Through = Role.members.through

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

                for p_id in parents.get(r_id, []):

                    user_roles[u_id].add(roles[p_id])

                    ous.setdefault(r.ou, set()).add(user)

            if roles_with_attributes:

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

                        for user in users:

                            logger.info(u'provisionning user %s to %s', user, audience)

                                }

                            })

            else:

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

                    if not audience:

                        continue

                    notify_agents({

                        '@type': 'provision',

                        'issuer': issuer,

        elif users:

            audience = [audience for ou in OU.objects.all()

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

            notify_agents({

                '@type': 'deprovision',

                'issuer': issuer,

            })

        global_roles = set(ous.get(None, []))

            sent_roles = set(ou_roles) | global_roles

            helper(ou, sent_roles)

import os

import json

import hashlib

from django.conf import settings

from django.utils.http import urlencode

from django.utils.six.moves.urllib import parse as urlparse

        return 0

    def update_settings(self, tenant_settings, tenant):

        tenant_settings.CSRF_COOKIE_NAME = 'csrftoken-%s' % domain_hash

        tenant_settings.SESSION_COOKIE_NAME = 'sessionid-%s' % domain_hash

        # unique but common name for authentic opened session cookie name

        if getattr(tenant_settings, 'TEMPLATE_VARS', None):

            idp_url = tenant_settings.TEMPLATE_VARS.get('idp_url')

            if idp_url:

                cookie_name = 'a2-opened-session-%s' % idp_hash

                tenant_settings.A2_OPENED_SESSION_COOKIE_NAME = cookie_name

                tenant_settings.MELLON_OPENED_SESSION_COOKIE_NAME = cookie_name

            if not getattr(tenant_settings, 'A2_IDP_OIDC_JWKSET', None):

                from jwcrypto import jwk

                jwkkey = jwk.JWK.from_pem(

                jwkset = jwk.JWKSet()

                jwkset['keys'].add(jwkkey)

                tenant_settings.A2_IDP_OIDC_JWKSET = json.loads(jwkset.export())

        ]

    }

    hobo_json_content = json.dumps(env)

    hobo_json.write(hobo_json_content)

    hobo_json.flush()

def test_import_template(db, tenant_base):

    def with_uuid_removed(input):

        if isinstance(input, dict):

                if key == 'uuid':

                    input.pop('uuid')

        elif isinstance(input, list):

            return [with_uuid_removed(e) for e in input]

        else:

            return input

        else:

    call_command('create_tenant', 'authentic.example.net')

    tenant = TenantMiddleware.get_tenant_by_hostname('authentic.example.net')

import pytest

from rest_framework.exceptions import AuthenticationFailed