Produits Entr'ouvert » Authentic 2

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

from django.contrib.contenttypes.models import ContentType

from django_rbac.models import Operation

from django_rbac.utils import (

    get_ou_model, get_role_model, get_role_parenting_model, get_permission_model)

from authentic2.a2_rbac.models import RoleAttribute

def update_model(obj, d):

    for attr, value in d.items():

        setattr(obj, attr, value)

    obj.save()

        self.role_attributes_update = role_attributes_update

class RoleDeserializer(object):

    def __init__(self, d, import_context):

        self._import_context = import_context

            else:

                self._role_d[key] = value

    def deserialize(self):

        ou_d = self._role_d['ou']

        has_ou = bool(ou_d)

        ou = None if not has_ou else search_ou(ou_d)

        if has_ou and not ou:

        kwargs = self._role_d.copy()

        kwargs.pop('ou', None)

            update_model(self._obj, kwargs)

        else:  # Create role

            if 'uuid' in kwargs and not kwargs['uuid']:

            self._obj = get_role_model().objects.create(**kwargs)

            status = 'created'

        self._obj.get_admin_role()

        return self._obj, status

    def attributes(self):

        """ Update attributes (delete everything then create)

        """

        return created, deleted

    def parentings(self):

        """ Update parentings (delete everything then create)

        """

            for parent_d in self._parents:

                parent = search_role(parent_d)

                if not parent:

                created.append(Parenting.objects.create(

                    child=self._obj, direct=True, parent=parent))

        return created, deleted

    def permissions(self):

        """ Update permissions (delete everything then create)

        """

    result = ImportResult()

    if not isinstance(json_d, dict):

    if import_context.import_ous:

        for ou_d in json_d.get('ous', []):

            result.update_ous(*import_ou(ou_d))

    if import_context.import_roles:

        for ds in roles_ds:

            result.update_roles(*ds.deserialize())

                result.update_permissions(*ds.permissions())

        if import_context.ou_delete_orphans:

        if import_context.role_delete_orphans:

            # FIXME : delete each role that is in DB but not in the export

    return result

import json

import inspect

from django.db import transaction

from django.views.generic.base import ContextMixin

from django.views.generic import (FormView, UpdateView, CreateView, DeleteView, TemplateView,

from django_rbac.utils import get_ou_model

from authentic2.forms.profile import modelform_factory

from authentic2.utils import redirect, batch_queryset

from authentic2.decorators import json as json_view

    def form_valid(self, form):

        try:

        except ValueError:

            form.add_error('site_json', _('File is not in the expected JSON format.'))

            return self.form_invalid(form)

        try:

            with transaction.atomic():

                import_site(json_site, ImportContext())

            return self.form_invalid(form)

        return super(SiteImportView, self).form_valid(form)

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import pytest

from authentic2.a2_rbac.models import RoleParenting

from authentic2.data_transfer import (

    export_site,

    ExportContext,

    export_roles,

    import_site,

    export_ous,

        'uuid': get_hex_uuid(), 'name': 'some role', 'description': 'role description',

        'slug': 'some-role', 'ou': {'slug': 'some-ou'}, 'service': None},

        ImportContext())

        rd.deserialize()

        'uuid': get_hex_uuid(), 'ou': None, 'service': None}

    rd = RoleDeserializer(child_role_dict, ImportContext())

    rd.deserialize()

        rd.parentings()

def test_role_deserializer_permissions(db):

def test_import_roles_role_delete_orphans(db):

    roles = [{

        'name': 'some role', 'description': 'some role description', 'slug': '_some-role'}]

        import_site({'roles': roles}, ImportContext(role_delete_orphans=True))

    import_site(d, ImportContext(import_roles=False, import_ous=False))

    assert Role.objects.exclude(slug__startswith='_').count() == 0

    assert OU.objects.exclude(slug='default').count() == 0

        import_site(d, ImportContext(import_roles=True, import_ous=False))

    assert 'missing Organizational' in e.value.args[0]

    assert Role.objects.exclude(slug__startswith='_').count() == 0

    d = export_site(ExportContext(export_ous=False))

    assert 'ous' not in d

import random

import json

from django.utils import six

from django.utils.six.moves import builtins as __builtin__

from django.core import management

def test_import_site_cmd_unhandled_context_option(db, monkeypatch, capsys, json_fixture):

    content = {

        'roles': [

            {

    Role.objects.create(uuid='dqfewrvesvews2532', slug='role-slug', name='role-name')

        management.call_command(

            'import_site', '-o', 'role-delete-orphans', json_fixture(content))

def test_import_site_empty_uuids(db, monkeypatch, json_fixture):

        management.call_command('import_site', json_fixture({

            'roles': [

                {