Produits Entr'ouvert » Authentic 2

from django_rbac.utils import get_role_model

Role = get_role_model()

    delete = attr.ib(default=False, metadata={'flag': True})

    clear = attr.ib(default=False, metadata={'flag': True})

SOURCE_NAME = '_source_name'

SOURCE_ID = '_source_id'

SOURCE_COLUMNS = set([SOURCE_NAME, SOURCE_ID])

ROLE_NAME = '_role_name'

ROLE_SLUG = '_role_slug'

SPECIAL_COLUMNS = SOURCE_COLUMNS | {ROLE_NAME, ROLE_SLUG}

    locals()[ROLE_NAME] = forms.CharField(

        label=_('Role name'),

        required=False)

    locals()[ROLE_SLUG] = forms.CharField(

        label=_('Role slug'),

        required=False)

    user_first_seen = attr.ib(default=True)

        if ROLE_NAME in header_names and ROLE_SLUG in header_names:

            self.add_error(

                Error('invalid-role-column',

                      _('Either specify role names or role slugs, not both')))

            elif header.name not in SPECIAL_COLUMNS:

                and header.name not in SPECIAL_COLUMNS):

    @property

    def allow_duplicate_key(self):

        return ROLE_NAME in self.headers_by_name or ROLE_SLUG in self.headers_by_name

                if user and self.allow_duplicate_key:

                    row.user_first_seen = False

                else:

                    errors.append(

                        Error('unique-constraint-failed',

                              _('Unique constraint on column "%(column)s" failed: '

                                'value already appear on line %(line)d') % {

                                    'column': header.name,

                                    'line': unique_map[unique_key]}))

                if user and self.allow_duplicate_key:

                    row.user_first_seen = False

                else:

                    errors.append(

                        Error('unique-constraint-failed',

                              _('Unique constraint on column "%s" failed') % cell.header.name))

        success = True

        if not row.user_first_seen:

            cell = next(c for c in row.cells if c.header.name in {ROLE_NAME, ROLE_SLUG})

            return self.add_role(cell, user)

        for cell in row.cells:

            if cell.header.field or cell.header.attribute:

                continue

            if cell.header.name in {ROLE_NAME, ROLE_SLUG}:

                success &= self.add_role(cell, user, do_clear=True)

        return success

    def add_role(self, cell, user, do_clear=False):

        try:

            if cell.header.name == ROLE_NAME:

                role = Role.objects.get(name=cell.value, ou=self.ou)

            elif cell.header.name == ROLE_SLUG:

                role = Role.objects.get(slug=cell.value, ou=self.ou)

        except Role.DoesNotExist:

            cell.errors.append(

                Error('role-not-found',

                      _('Role "%s" does not exist') % cell.value))

            return False

        if cell.header.delete:

            user.roles.remove(role)

        elif cell.header.clear:

            if do_clear:

                user.roles.clear()

            user.roles.add(role)

        else:

            user.roles.add(role)

        cell.action = 'updated'

    <h4 id="help-roles">{% trans "Role operations" %}</h4>

    <p>

      {% blocktrans trimmed %}

        Adding existing roles to users is supported. Use either

        <var>_role_name</var> or <var>_role_slug</var> special columns to

        specify the names or the slugs that should be added to the user. In

        order to add multiple roles, simply add a new line, identical to the

        first one, except for the value of the role cell. These columns also

        accept special flags, as listed below.

      {% endblocktrans %}

    </p>

    <table class="main left">

      <thead>

        <tr>

          <th>{% trans "Flag" %}</th>

          <th>{% trans "Meaning" %}</th>

          <th>{% trans "Default value" %}</th>

        </tr>

      </thead>

      <tbody>

        <tr>

          <td>delete</td>

          <td>

            {% blocktrans trimmed %}

              Remove role from user instead of adding it.

            {% endblocktrans %}

          </td>

          <td>{% trans "False" %}</td>

        </tr>

        <tr>

          <td>clear</td>

          <td>

            {% blocktrans trimmed %}

            Clear user roles beforehand, so that they will have no more roles

            than those specified in the import file.

            {% endblocktrans %}

          </td>

          <td>{% trans "False" %}</td>

        </tr>

      </tbody>

    </table>

</pre>

    </blockquote>

    <p>{% blocktrans trimmed %}Importing email, first and last name of users

    while adding roles.{% endblocktrans %}</p>

    <blockquote>

      <pre>email key,first_name,last_name,_role_name

john.doe@example.com,John,Doe,Role1

john.doe@example.com,John,Doe,Role2

from django_rbac.utils import get_role_model

Role = get_role_model()

def test_user_roles_csv(profile, user_csv_importer_factory):

    role_name = 'test_name'

    role_slug = 'test_slug'

    role = Role.objects.create(name=role_name, slug=role_slug, ou=get_default_ou())

    role2 = Role.objects.create(name='test2', ou=get_default_ou())

    base_header = 'email key,first_name,last_name,phone,'

    base_user = 'tnoel@entrouvert.com,Thomas,Noël,1234,'

    content_name_add = '\n'.join((base_header + '_role_name', base_user + role_name))

    importer = user_csv_importer_factory(content_name_add)

    assert importer.run()

    thomas = User.objects.get(email='tnoel@entrouvert.com')

    assert thomas in role.members.all()

    thomas.roles.add(role2)

    importer = user_csv_importer_factory(content_name_add)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas in role2.members.all()

    content_name_delete = '\n'.join((base_header + '_role_name delete', base_user + role_name))

    importer = user_csv_importer_factory(content_name_delete)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas not in role.members.all()

    assert thomas in role2.members.all()

    content_name_clear = '\n'.join((base_header + '_role_name clear', base_user + role_name))

    importer = user_csv_importer_factory(content_name_clear)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas in role.members.all()

    assert thomas not in role2.members.all()

    thomas.roles.remove(role)

    content_name_add_multiple = '\n'.join((base_header + '_role_name', base_user + role_name,

                                           base_user + 'test2'))

    importer = user_csv_importer_factory(content_name_add_multiple)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas in role.members.all()

    assert thomas in role2.members.all()

    thomas.roles.remove(role)

    thomas.roles.remove(role2)

    content_name_clear_multiple = '\n'.join((base_header + '_role_name clear',

                                             base_user + role_name,

                                             base_user + 'test2'))

    importer = user_csv_importer_factory(content_name_clear_multiple)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas in role.members.all()

    assert thomas in role2.members.all()

    thomas.roles.remove(role)

    content_slug_add = '\n'.join((base_header + '_role_slug', base_user + role_slug))

    importer = user_csv_importer_factory(content_slug_add)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas in role.members.all()

    thomas.roles.remove(role)

    content_only_key = '''email key,_role_name

tnoel@entrouvert.com,test_name'''

    importer = user_csv_importer_factory(content_slug_add)

    assert importer.run()

    thomas.refresh_from_db()

    assert thomas in role.members.all()

    content_name_error = '\n'.join((base_header + '_role_name', base_user + 'bad_name'))

    importer = user_csv_importer_factory(content_name_error)

    assert importer.run()

    assert importer.has_errors

    assert importer.rows[0].cells[-1].errors[0].code == 'role-not-found'

    content_header_error = '\n'.join((base_header + '_role_name,_role_slug',

                                      base_user + ','.join((role_name, role_slug))))

    importer = user_csv_importer_factory(content_header_error)

    assert not importer.run()

    assert importer.has_errors

    assert importer.errors[0].code == 'invalid-role-column'