Exemple #1
0
class UserField(forms.ChoiceField):
    widget = widgets.Select()

    def __init__(self, *args, **kwargs):
        kwargs.pop('max_length', None)
        self._exclude = kwargs.pop('exclude', [])
        super(UserField, self).__init__(*args, **kwargs)

    def prepare_value(self, value):
        rv = super(UserField, self).prepare_value(value)
        if rv:
            try:
                FreeNAS_User(rv, flags=FLAGS_DBINIT)
            except:
                rv = 'nobody'
        return rv

    def _reroll(self):
        from freenasUI.account.forms import FilteredSelectJSON
        try:
            users = FreeNAS_Users(flags=FLAGS_DBINIT | FLAGS_CACHE_READ_USER)
        except:
            users = []
        if len(users) > 500:
            if self.initial:
                self.choices = ((self.initial, self.initial), )
            kwargs = {}
            if len(self._exclude) > 0:
                kwargs['exclude'] = ','.join(self._exclude)
            self.widget = FilteredSelectJSON(url=("account_bsduser_json", None,
                                                  (), kwargs))
        else:
            ulist = []
            if not self.required:
                ulist.append(('-----', 'N/A'))
            ulist.extend(
                map(
                    lambda x: (
                        x.pw_name,
                        x.pw_name,
                    ),
                    filter(
                        lambda y:
                        (y is not None and y.pw_name not in self._exclude),
                        users)))

            self.widget = widgets.FilteringSelect()
            self.choices = ulist

    def clean(self, user):
        if not self.required and user in ('-----', '', None):
            return None
        try:
            u = FreeNAS_User(user, flags=FLAGS_DBINIT)
        except:
            u = None

        if u is None:
            raise forms.ValidationError(_("The user %s is not valid.") % user)
        return user
class GroupField(forms.ChoiceField):
    widget = widgets.Select()

    def __init__(self, *args, **kwargs):
        kwargs.pop('max_length', None)
        super(GroupField, self).__init__(*args, **kwargs)

    def prepare_value(self, value):
        rv = super(GroupField, self).prepare_value(value)
        if rv:
            try:
                FreeNAS_Group(rv, flags=FLAGS_DBINIT)
            except:
                rv = 'nobody'
        return rv

    def _reroll(self):
        from freenasUI.account.forms import FilteredSelectJSON
        try:
            groups = FreeNAS_Groups(flags=FLAGS_DBINIT
                                    | FLAGS_CACHE_READ_GROUP)
        except:
            groups = []
        if len(groups) > 500:
            if self.initial:
                self.choices = ((self.initial, self.initial), )
            self.widget = FilteredSelectJSON(attrs=self.widget.attrs,
                                             url=("account_bsdgroup_json", ))
        else:
            glist = []
            if not self.required:
                glist.append(('-----', 'N/A'))
            notbuiltin = [
                o[0] for o in bsdGroups.objects.filter(
                    bsdgrp_builtin=False).values_list('bsdgrp_gid')
            ]
            glist.extend([(x.gr_name, x.gr_name) for x in sorted(
                groups, key=lambda y: (y.gr_gid not in notbuiltin, y.gr_name))
                          ])
            #self.choices = glist
            self.widget = FilteredSelectJSON(attrs=self.widget.attrs,
                                             url=("account_bsdgroup_json", ),
                                             choices=glist)

    def clean(self, group):
        if not self.required and group in ('-----', '', None):
            return None
        try:
            g = FreeNAS_Group(group, flags=FLAGS_DBINIT)
        except:
            g = None

        if g is None:
            raise forms.ValidationError(
                _("The group %s is not valid.") % group)
        return group
Exemple #3
0
class GroupField(forms.ChoiceField):
    widget = widgets.Select()

    def __init__(self, *args, **kwargs):
        kwargs.pop('max_length', None)
        super(GroupField, self).__init__(*args, **kwargs)

    def prepare_value(self, value):
        rv = super(GroupField, self).prepare_value(value)
        if rv:
            try:
                FreeNAS_Group(rv, flags=FLAGS_DBINIT)
            except:
                rv = 'nobody'
        return rv

    def _reroll(self):
        from freenasUI.account.forms import FilteredSelectJSON
        try:
            groups = FreeNAS_Groups(flags=FLAGS_DBINIT
                                    | FLAGS_CACHE_READ_GROUP)
        except:
            groups = []
        if len(groups) > 500:
            if self.initial:
                self.choices = ((self.initial, self.initial), )
            self.widget = FilteredSelectJSON(url=("account_bsdgroup_json", ))
        else:
            glist = []
            if not self.required:
                glist.append(('-----', 'N/A'))
            glist.extend([(x.gr_name, x.gr_name) for x in groups])
            self.widget = widgets.FilteringSelect()
            self.choices = glist

    def clean(self, group):
        if not self.required and group in ('-----', '', None):
            return None
        try:
            g = FreeNAS_Group(group, flags=FLAGS_DBINIT)
        except:
            g = None

        if g is None:
            raise forms.ValidationError(
                _("The group %s is not valid.") % group)
        return group
Exemple #4
0
class UserField(forms.ChoiceField):
    widget = widgets.Select()

    def __init__(self, *args, **kwargs):
        kwargs.pop('max_length', None)
        self._exclude = kwargs.pop('exclude', [])
        super(UserField, self).__init__(*args, **kwargs)

    def prepare_value(self, value):
        rv = super(UserField, self).prepare_value(value)
        if rv:
            try:
                FreeNAS_User(rv, flags=FLAGS_DBINIT)
            except:
                log.warn('Failed to get user', exc_info=True)
                rv = 'nobody'
        return rv

    def _reroll(self):
        from freenasUI.account.forms import FilteredSelectJSON
        try:
            users = FreeNAS_Users(flags=FLAGS_DBINIT | FLAGS_CACHE_READ_USER)
        except:
            users = []
        kwargs = {
            'api_name': 'v1.0',
            'resource_name': 'account/all_users'
        }
        if len(users) > 500:
            if self.initial:
                self.choices = ((self.initial, self.initial),)
            if len(self._exclude) > 0:
                kwargs['exclude'] = ','.join(self._exclude)
            self.widget = FilteredSelectJSON(
                attrs=self.widget.attrs,
                url=reverse('api_dispatch_list', kwargs=kwargs)
            )
        else:
            ulist = []
            if not self.required:
                ulist.append(('-----', 'N/A'))
            notbuiltin = [
                o[0]
                for o in bsdUsers.objects.filter(
                    bsdusr_builtin=False
                ).values_list('bsdusr_uid')
            ]
            ulist.extend(
                [(x.pw_name, x.pw_name, ) for x in sorted([y for y in users if (
                            y is not None and y.pw_name not in self._exclude
                        )], key=lambda y: (y.pw_uid not in notbuiltin, y.pw_name))]
            )

            self.widget = FilteredSelectJSON(
                attrs=self.widget.attrs,
                url=reverse('api_dispatch_list', kwargs=kwargs),
                choices=ulist
            )
            #self.choices = ulist

    def clean(self, user):
        if not self.required and user in ('-----', '', None):
            return None
        try:
            u = FreeNAS_User(user, flags=FLAGS_DBINIT)
        except:
            log.warn('Failed to get user', exc_info=True)
            u = None

        if u is None:
            raise forms.ValidationError(_("The user %s is not valid.") % user)
        return user
Exemple #5
0
class UserField(forms.ChoiceField):
    widget = widgets.Select()

    def __init__(self, *args, **kwargs):
        kwargs.pop('max_length', None)
        self._exclude = kwargs.pop('exclude', [])
        super(UserField, self).__init__(*args, **kwargs)

    def prepare_value(self, value):
        rv = super(UserField, self).prepare_value(value)
        if rv:
            try:
                with client as c:
                    c.call('dscache.get_uncached_user', rv)
            except:
                log.warn('Failed to get user', exc_info=True)
                rv = 'nobody'
        return rv

    def _reroll(self):
        from freenasUI.account.forms import FilteredSelectJSON
        try:
            with client as c:
                users = c.call('users.query',
                               {'extra': {
                                   'search_dscache': True
                               }})
        except:
            users = []
        kwargs = {'api_name': 'v1.0', 'resource_name': 'account/all_users'}
        if len(users) > 500:
            if self.initial:
                self.choices = ((self.initial, self.initial), )
            if len(self._exclude) > 0:
                kwargs['exclude'] = ','.join(self._exclude)
            self.widget = FilteredSelectJSON(attrs=self.widget.attrs,
                                             url=reverse('api_dispatch_list',
                                                         kwargs=kwargs))
        else:
            ulist = []
            if not self.required:
                ulist.append(('-----', 'N/A'))
            notbuiltin = [
                o[0] for o in bsdUsers.objects.filter(
                    bsdusr_builtin=False).values_list('bsdusr_uid')
            ]
            ulist.extend([
                (x['username'],
                 x['username']) for x in sorted([
                     y for y in users
                     if (y is not None and y['username'] not in self._exclude)
                 ],
                                                key=lambda y:
                                                (y['uid'] not in notbuiltin, y[
                                                    'username']))
            ])

            self.widget = FilteredSelectJSON(attrs=self.widget.attrs,
                                             url=reverse('api_dispatch_list',
                                                         kwargs=kwargs),
                                             choices=ulist)
            #self.choices = ulist

    def clean(self, user):
        if not self.required and user in ('-----', '', None):
            return None
        try:
            with client as c:
                u = c.call('dscache.get_uncached_user', user)
        except:
            log.warn('Failed to get user', exc_info=True)
            u = None

        if u is None:
            raise forms.ValidationError(_("The user %s is not valid.") % user)
        return user
Exemple #6
0
class GroupField(forms.ChoiceField):
    widget = widgets.Select()

    def __init__(self, *args, **kwargs):
        kwargs.pop('max_length', None)
        super(GroupField, self).__init__(*args, **kwargs)

    def prepare_value(self, value):
        rv = super(GroupField, self).prepare_value(value)
        if rv:
            try:
                with client as c:
                    g = c.call('dscache.get_uncached_group', rv)
            except:
                rv = 'nobody'
        return rv

    def _reroll(self):
        from freenasUI.account.forms import FilteredSelectJSON
        try:
            with client as c:
                groups = c.call('groups.query',
                                {'extra': {
                                    'search_dscache': True
                                }})
        except:
            groups = []
        kwargs = {'api_name': 'v1.0', 'resource_name': 'account/all_groups'}
        if len(groups) > 500:
            if self.initial:
                self.choices = ((self.initial, self.initial), )
            self.widget = FilteredSelectJSON(attrs=self.widget.attrs,
                                             url=reverse('api_dispatch_list',
                                                         kwargs=kwargs))
        else:
            glist = []
            if not self.required:
                glist.append(('-----', 'N/A'))
            notbuiltin = [
                o[0] for o in bsdGroups.objects.filter(
                    bsdgrp_builtin=False).values_list('bsdgrp_gid')
            ]
            glist.extend([(x['group'], x['group']) for x in sorted(
                groups, key=lambda y: (y['gid'] not in notbuiltin, y['group']))
                          ])
            #self.choices = glist
            self.widget = FilteredSelectJSON(attrs=self.widget.attrs,
                                             url=reverse('api_dispatch_list',
                                                         kwargs=kwargs),
                                             choices=glist)

    def clean(self, group):
        if not self.required and group in ('-----', '', None):
            return None
        try:
            with client as c:
                g = c.call('dscache.get_uncached_group', group)
        except:
            g = None

        if g is None:
            raise forms.ValidationError(
                _("The group %s is not valid.") % group)
        return group