Produits Entr'ouvert » Authentic 2

from authentic2.utils import get_object_by_main_attr, ImportExportError

    @classmethod

    def import_json(cls, data):

        from authentic2.models import Service

        ou_json = data.pop('ou', {})

        service_json = data.pop('service', {})

        attributes_json = data.pop('attributes', {})

        # if not ou stop import

        ou = get_object_by_main_attr(OrganizationalUnit, **ou_json)

        if not ou:

            raise ImportExportError('OU (%(uuid)s, %(slug)s, %(name)s) does not exist.' % ou_json)

        # get role's service or raise an exception if none is found

        service = None

        if service_json:

            service_json.pop('ou')

            service = get_object_by_main_attr(Service, **service_json)

            if not service:

                raise ImportExportError('Service (%(slug)s, %(name)s) does not exist.' % service_json)

        kwargs = {'uuid': data['uuid'], 'slug': data['slug'], 'name': data['name']}

        role, created = cls.objects.get_or_create(ou=ou, **kwargs)

        # set service

        if service:

            service.roles.add(role)

        # set attributes

        for attr in attributes_json:

            attribute, created = RoleAttribute.objects.get_or_create(

                role=role, name=attr['name'], kind=attr['kind'], defaults={

                    'value': attr['value']})

            if created:

                attribute.value = attr['value']

                attribute.save()

    def export_json(self):

        data = {

            'uuid': self.uuid,

            'slug': self.slug,

            'name': self.name,

        }

        if self.ou:

            data['ou'] = {

                'uuid': self.ou.uuid,

                'name': self.ou.name,

                'slug': self.ou.slug

            }

        if self.service:

            data['service'] = self.service.export_json()

        attributes = []

        for attr in self.attributes.all():

            attributes.append({

                'name': attr.name, 'kind': attr.kind,

                'value': attr.value})

        data['attributes'] = attributes

        parents = []

        for parent in self.parents(include_self=False):

            parents.append({

                'uuid': parent.uuid, 'slug': parent.slug, 'name': parent.name})

        data['parents'] = parents

        return data

import json

from optparse import make_option

import sys

from django.core.management import BaseCommand

from authentic2.utils import export_roles

class Command(BaseCommand):

    help = 'Export roles as json'

    args = '<filename>'

    option_list = BaseCommand.option_list + (

        make_option('--ou', dest='ou', default=None, type=str,

                    help='restrict to the organizational unit slug'),)

    def handle(self, *args, **options):

        if len(args) < 1:

            output = sys.stdout

        else:

            output = open(args[0], 'w')

        data = export_roles(ou_slug=options['ou'])

        json.dump(data, output, encoding='utf-8', indent=4)

import json

from optparse import make_option

from django.core.management.base import BaseCommand, CommandError

from authentic2.utils import import_roles, ImportExportError

class Command(BaseCommand):

    help = 'Import roles from json file'

    args = '<filename>'

    option_list = BaseCommand.option_list + (

        make_option('--ou', dest='ou', default=None, type=str,

                    help='restrict to the organizational unit slug'),

        make_option('--stop-on-absent-parent', action='store_true', dest='stop_absent_parent', default=False,

                    help='stop if parent is absent')

    )

    def handle(self, *args, **options):

        if args:

            fd = open(args[0])

            try:

                import_roles(json.load(fd), **options)

            except(ImportExportError,) as exc:

                raise CommandError(exc.message)

    @classmethod

    def import_json(cls, data):

        ou = data.pop('ou')

        cls.objects.get_or_create(ou=ou, **data)

    def export_json(self):

        return {

            'name': self.name, 'slug': self.slug,

            'ou': {

                'uuid': self.ou.uuid, 'slug': self.ou.slug, 'name': self.ou.name

            }

        }

from django.db import transaction

from django.core.exceptions import ImproperlyConfigured, PermissionDenied, FieldError

class ImportExportError(Exception):

    pass

def get_object_by_main_attr(obj, uuid=None, slug=None, name=None, create=False):

    """Sequentially try to get an object by uuid, slug, then name.

    Creates one if <create> is True

    """

    try:

        return obj.objects.get(uuid=uuid)

    except (obj.DoesNotExist, FieldError):

        try:

            return obj.objects.get(slug=slug)

        except (obj.DoesNotExist, FieldError):

            try:

                return obj.objects.get(name=name)

            except (obj.DoesNotExist, FieldError):

                pass

    if create:

        return obj.objects.create(uuid=uuid, slug=slug, name=name)

    return None

def export_roles(ou_slug=None):

    from django_rbac.utils import get_role_model

    Role = get_role_model()

    filters = {'slug__startswith': '_'}

    if ou_slug:

        roles = Role.objects.filter(ou__slug=ou_slug).exclude(**filters)

    else:

        roles = Role.objects.exclude(**filters)

    return [role.export_json() for role in roles]

def import_roles(data, **options):

    from django_rbac.utils import get_role_model

    Role = get_role_model()

    ou_slug = options.pop('ou')

    stop_absent_parent = options.pop('stop_absent_parent')

    if ou_slug:

        data = [datum for datum in data if datum['ou']['slug'] == ou_slug]

    with transaction.atomic():

        for role_json in data:

            Role.import_json(role_json)

        # once all roles are created, set their relationships

        for role_json in data:

            role = Role.objects.get(uuid=role_json['uuid'])

            for parent_json in role_json.get('parents', []):

                parent = get_object_by_main_attr(Role, **parent_json)

                if parent:

                    role.add_parent(parent)

                else:

                    if stop_absent_parent:

                        raise ImportExportError(

                            'Parent role (%(uuid)s, %(slug)s, %(name)s does not exist.' % parent_json)