Пример #1
0
class DomainForm(MAASModelForm):
    """Domain creation/edition form."""
    class Meta:
        model = Domain
        fields = (
            'name',
            'authoritative',
            'ttl',
        )

    ttl = forms.IntegerField(min_value=1, max_value=604800, required=False)

    authoritative = forms.NullBooleanField(required=False)

    def _post_clean(self):
        # ttl=None needs to make it through.  See also APIEditMixin
        self.cleaned_data = {
            key: value
            for key, value in self.cleaned_data.items()
            if value is not None or key == 'ttl'
        }
        super(APIEditMixin, self)._post_clean()
Пример #2
0
class ConfigContextBulkEditForm(BulkEditForm):
    pk = forms.ModelMultipleChoiceField(
        queryset=ConfigContext.objects.all(),
        widget=forms.MultipleHiddenInput
    )
    weight = forms.IntegerField(
        required=False,
        min_value=0
    )
    is_active = forms.NullBooleanField(
        required=False,
        widget=BulkEditNullBooleanSelect()
    )
    description = forms.CharField(
        required=False,
        max_length=100
    )

    class Meta:
        nullable_fields = [
            'description',
        ]
Пример #3
0
class TalkActionForm(forms.Form):
    talks = forms.MultipleChoiceField(choices=[])
    decision = forms.NullBooleanField(label=_('Accept talk?'))
    track = forms.ChoiceField(required=False,
                              choices=[],
                              label=_('Assign to a track'))
    room = forms.ChoiceField(required=False,
                             choices=[],
                             label=_('Put in a room'))

    def __init__(self, *args, **kwargs):
        site = kwargs.pop('site')
        talks = kwargs.pop('talks')
        super().__init__(*args, **kwargs)
        self.fields['talks'].choices = [(talk.slug, None)
                                        for talk in talks.all()]
        tracks = Track.objects.filter(site=site)
        self.fields['track'].choices = [(None, "---------")] + list(
            tracks.values_list('slug', 'name'))
        rooms = Room.objects.filter(site=site)
        self.fields['room'].choices = [(None, "---------")] + list(
            rooms.values_list('slug', 'name'))
Пример #4
0
class PowerFeedBulkEditForm(AddRemoveTagsForm, CustomFieldModelBulkEditForm):
    pk = forms.ModelMultipleChoiceField(queryset=PowerFeed.objects.all(),
                                        widget=forms.MultipleHiddenInput)
    power_panel = DynamicModelChoiceField(queryset=PowerPanel.objects.all(),
                                          required=False)
    rack = DynamicModelChoiceField(
        queryset=Rack.objects.all(),
        required=False,
    )
    status = forms.ChoiceField(
        choices=add_blank_choice(PowerFeedStatusChoices),
        required=False,
        initial='',
        widget=StaticSelect())
    type = forms.ChoiceField(choices=add_blank_choice(PowerFeedTypeChoices),
                             required=False,
                             initial='',
                             widget=StaticSelect())
    supply = forms.ChoiceField(
        choices=add_blank_choice(PowerFeedSupplyChoices),
        required=False,
        initial='',
        widget=StaticSelect())
    phase = forms.ChoiceField(choices=add_blank_choice(PowerFeedPhaseChoices),
                              required=False,
                              initial='',
                              widget=StaticSelect())
    voltage = forms.IntegerField(required=False)
    amperage = forms.IntegerField(required=False)
    max_utilization = forms.IntegerField(required=False)
    mark_connected = forms.NullBooleanField(required=False,
                                            widget=BulkEditNullBooleanSelect)
    comments = CommentField(widget=SmallTextarea, label='Comments')

    class Meta:
        nullable_fields = [
            'location',
            'comments',
        ]
Пример #5
0
class BuildingForm(gis_forms.ModelForm):
    name = forms.CharField(max_length=100, widget=forms.TextInput(
        attrs={'class': 'col-sm-12 col-lg-12 form-control'}
    ))
    type = forms.ModelChoiceField(required=False, queryset=models.BuildingType.objects.filter(status='R'), widget=forms.Select(
        attrs={'class': 'col-sm-12 col-lg-12 form-control'}
    ))
    location = forms.ModelChoiceField(required=False, queryset=models.Location.objects.filter(status='R'), widget=forms.Select(
        attrs={'class': 'col-sm-12 col-lg-12 form-control'}
    ))
    geom = gis_forms.PointField(widget=gis_forms.OSMWidget(
        attrs={}
    ))
    old_madrid = forms.NullBooleanField(required=False, widget=forms.Select(
        attrs={'class': 'col-sm-12 col-lg-12 form-control'},
        choices=[(1, 'Yes'), (0, 'No'), (2, 'N/A')]
    ))
    complete = forms.BooleanField(required=False)

    class Meta:
        model = models.Building
        exclude = ['status']
Пример #6
0
    def filter_queryset(self, request, queryset, view):

        if not django_settings.WALDUR_CORE['ENABLE_ACCOUNTING_START_DATE']:
            return queryset

        value = request.query_params.get('accounting_is_running')
        boolean_field = forms.NullBooleanField()

        try:
            value = boolean_field.to_python(value)
        except exceptions.ValidationError:
            value = None

        if value is None:
            return queryset

        query = Q(accounting_start_date__gt=timezone.now())

        if value:
            return queryset.exclude(query)
        else:
            return queryset.filter(query)
Пример #7
0
class CustomFieldFilterForm(BootstrapMixin, forms.Form):
    field_groups = [
        ['q'],
        ['type', 'content_types'],
        ['weight', 'required'],
    ]
    q = forms.CharField(
        required=False,
        widget=forms.TextInput(attrs={'placeholder': _('All Fields')}),
        label=_('Search'))
    content_types = ContentTypeMultipleChoiceField(
        queryset=ContentType.objects.all(),
        limit_choices_to=FeatureQuery('custom_fields'),
        required=False)
    type = forms.MultipleChoiceField(choices=CustomFieldTypeChoices,
                                     required=False,
                                     widget=StaticSelectMultiple(),
                                     label=_('Field type'))
    weight = forms.IntegerField(required=False)
    required = forms.NullBooleanField(
        required=False,
        widget=StaticSelect(choices=BOOLEAN_WITH_BLANK_CHOICES))
Пример #8
0
class DirectPeeringSessionFilterForm(BootstrapMixin, forms.Form):
    model = DirectPeeringSession
    q = forms.CharField(required=False, label="Search")
    local_autonomous_system_id = DynamicModelChoiceField(
        required=False,
        queryset=AutonomousSystem.objects.all(),
        query_params={"affiliated": True},
        to_field_name="pk",
        label="Local autonomous system",
    )
    autonomous_system_id = DynamicModelChoiceField(
        required=False,
        queryset=AutonomousSystem.objects.all(),
        to_field_name="pk",
        label="Autonomous system",
    )
    bgp_group_id = DynamicModelMultipleChoiceField(
        required=False,
        queryset=BGPGroup.objects.all(),
        to_field_name="pk",
        null_option="None",
        label="BGP group",
    )
    address_family = forms.ChoiceField(required=False,
                                       choices=IPFamily.choices,
                                       widget=StaticSelect)
    enabled = forms.NullBooleanField(required=False,
                                     widget=CustomNullBooleanSelect)
    relationship = forms.MultipleChoiceField(required=False,
                                             choices=BGPRelationship.choices,
                                             widget=StaticSelectMultiple)
    router_id = DynamicModelMultipleChoiceField(
        required=False,
        queryset=Router.objects.all(),
        to_field_name="pk",
        null_option="None",
    )
    tag = TagFilterField(model)
Пример #9
0
class DirectPeeringSessionBulkEditForm(BootstrapMixin, BulkEditForm):
    pk = FilterChoiceField(
        queryset=DirectPeeringSession.objects.all(), widget=forms.MultipleHiddenInput
    )
    enabled = forms.NullBooleanField(
        required=False, label="Enable", widget=CustomNullBooleanSelect
    )
    bgp_group = forms.ModelChoiceField(
        required=False,
        queryset=BGPGroup.objects.all(),
        label="BGP Group",
        widget=APISelect(api_url="/api/peering/bgp-groups/"),
    )
    import_routing_policies = FilterChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.all(),
        widget=APISelectMultiple(
            api_url="/api/peering/routing-policies/",
            query_filters={"type": "import-policy"},
        ),
    )
    export_routing_policies = FilterChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.all(),
        widget=APISelectMultiple(
            api_url="/api/peering/routing-policies/",
            query_filters={"type": "export-policy"},
        ),
    )
    router = forms.ModelChoiceField(
        required=False,
        queryset=Router.objects.all(),
        widget=APISelect(api_url="/api/peering/routers/"),
    )
    comment = CommentField()

    class Meta:
        nullable_fields = ["router", "comment"]
Пример #10
0
class FilterAttacksForm(FormWithRequest):
    search = forms.CharField(required=False)
    is_special = forms.NullBooleanField(required=False,
                                        initial=None,
                                        label=_('Special'))
    ordering = forms.ChoiceField(choices=[
        ('damage', _('Damage')),
        ('energy_increase', _('Energy Increase')),
        ('critical_hit_chance', _('Critical Hit Chance')),
        ('duration', _('Duration')),
        ('energy_requirement', _('Energy Requirement')),
    ],
                                 initial='damage',
                                 required=False)
    reverse_order = forms.BooleanField(initial=False, required=False)

    def __init__(self, *args, **kwargs):
        super(FilterAttacksForm, self).__init__(*args, **kwargs)
        self.fields['type'].required = False

    class Meta:
        model = models.Attack
        fields = ('search', 'type', 'is_special', 'ordering', 'reverse_order')
Пример #11
0
class InventoryItemFilterForm(DeviceComponentFilterForm):
    model = InventoryItem
    field_groups = [
        ['q', 'tag'],
        [
            'name', 'label', 'manufacturer_id', 'serial', 'asset_tag',
            'discovered'
        ],
        [
            'region_id', 'site_group_id', 'site_id', 'location_id',
            'virtual_chassis_id', 'device_id'
        ],
    ]
    manufacturer_id = DynamicModelMultipleChoiceField(
        queryset=Manufacturer.objects.all(),
        required=False,
        label=_('Manufacturer'))
    serial = forms.CharField(required=False)
    asset_tag = forms.CharField(required=False)
    discovered = forms.NullBooleanField(
        required=False,
        widget=StaticSelect(choices=BOOLEAN_WITH_BLANK_CHOICES))
    tag = TagFilterField(model)
class StoreUpdatePricingForm(forms.Form):
    discover_urls_concurrency = forms.IntegerField(min_value=1,
                                                   max_value=10,
                                                   required=False)
    products_for_url_concurrency = forms.IntegerField(min_value=1,
                                                      max_value=20,
                                                      required=False)
    async = forms.NullBooleanField()
    categories = forms.ModelMultipleChoiceField(
        queryset=Category.objects.none(), required=False)

    @classmethod
    def from_store_and_user(cls, store, user, data):
        valid_categories = get_objects_for_user(user,
                                                'update_category_pricing',
                                                store.scraper_categories())

        cls.base_fields['categories'].queryset = valid_categories

        return cls(data)

    def default_categories(self):
        return self.fields['categories'].queryset
Пример #13
0
class SignupForm(UserCreationForm):
    gender = forms.NullBooleanField(
        widget=forms.Select(attrs={'class': 'signup-gender'},
                            choices=[(True, 'Male'), (False, 'Female')]))

    email = forms.EmailField(widget=forms.EmailInput(
        attrs={'class': 'signup-email'}))
    name = forms.CharField(widget=forms.TextInput(
        attrs={'class': 'signup-name'}))
    password1 = forms.CharField(
        widget=forms.PasswordInput(attrs={'class': 'signup-password'}),
        label='Password')
    password2 = forms.CharField(
        widget=forms.PasswordInput(attrs={'class': 'signup-password'}),
        label='Confirm Password')

    class Meta:
        model = User
        fields = (
            'email',
            'name',
            'gender',
        )
Пример #14
0
class ManyFieldsExampleForm(forms.Form):
	 booleanfield = forms.BooleanField(label="BooleanField")
	 charfield = forms.CharField(label="CharField")
	 choicefield = forms.ChoiceField(label="ChoiceField")
	 typedchoicefield = forms.TypedChoiceField(label="TypedChoiceField")
	 datefield = forms.DateField(label="DateField")
	 datetimefield = forms.DateTimeField(label="DateTimeField")
	 decimalfield = forms.DecimalField(label="DecimalField")
	 durationfield = forms.DurationField(label="DurationField")
	 emailfield = forms.EmailField(label="EmailField")
	 filefield = forms.FileField(label="FileField")
	 filepathfield = forms.FilePathField(label="FilePathField", path="/")
	 floatfield = forms.FloatField(label="FloatField")
	 imagefield = forms.ImageField(label="ImageField")
	 integerfield = forms.IntegerField(label="IntegerField")
	 genericipaddressfield = forms.GenericIPAddressField(label="GenericIPAddressField")
	 multiplechoicefield = forms.MultipleChoiceField(label="MultipleChoiceField", choices=CONTINENTS)
	 typedmultiplechoicefield = forms.TypedMultipleChoiceField(label="TypedMultipleChoiceField", choices=CONTINENTS)
	 nullbooleanfield = forms.NullBooleanField(label="NullBooleanField")
	 slugfield = forms.SlugField(label="SlugField")
	 timefield = forms.TimeField(label="TimeField")
	 urlfield = forms.URLField(label="URLField")
	 uuidfield = forms.UUIDField(label="UUIDField")
Пример #15
0
class VRFBulkEditForm(BootstrapMixin, AddRemoveTagsForm, CustomFieldModelBulkEditForm):
    pk = forms.ModelMultipleChoiceField(
        queryset=VRF.objects.all(),
        widget=forms.MultipleHiddenInput()
    )
    tenant = DynamicModelChoiceField(
        queryset=Tenant.objects.all(),
        required=False
    )
    enforce_unique = forms.NullBooleanField(
        required=False,
        widget=BulkEditNullBooleanSelect(),
        label='Enforce unique space'
    )
    description = forms.CharField(
        max_length=100,
        required=False
    )

    class Meta:
        nullable_fields = [
            'tenant', 'description',
        ]
Пример #16
0
class ScheduledTaskFilterForm(BootstrapMixin, forms.ModelForm):
    model = ScheduledTask
    q = forms.CharField(required=False, label="Search")
    task_type = forms.MultipleChoiceField(
        label="Type", choices=TaskTypeChoices, required=False, widget=StaticSelect2Multiple()
    )
    status = forms.MultipleChoiceField(
        label="Status", choices=TaskStatusChoices, required=False, widget=StaticSelect2Multiple()
    )
    confirmed = forms.NullBooleanField(
        required=False, label="Is Confirmed (ACK)", widget=StaticSelect2(choices=BOOLEAN_WITH_BLANK_CHOICES)
    )
    scheduled_time_after = forms.DateTimeField(
        label=mark_safe("<br/>Scheduled After"), required=False, widget=DateTimePicker()
    )
    scheduled_time_before = forms.DateTimeField(label="Scheduled Before", required=False, widget=DateTimePicker())
    start_time_after = forms.DateTimeField(
        label=mark_safe("<br/>Started After"), required=False, widget=DateTimePicker()
    )
    start_time_before = forms.DateTimeField(label="Started Before", required=False, widget=DateTimePicker())
    end_time_after = forms.DateTimeField(label=mark_safe("<br/>Ended After"), required=False, widget=DateTimePicker())
    end_time_before = forms.DateTimeField(label="Ended Before", required=False, widget=DateTimePicker())

    class Meta:
        model = ScheduledTask
        fields = [
            "q",
            "task_type",
            "status",
            "confirmed",
            "scheduled_time_after",
            "scheduled_time_before",
            "start_time_after",
            "start_time_before",
            "end_time_after",
            "end_time_before",
        ]
Пример #17
0
class PhysicalInterfaceForm(InterfaceForm):
    """Form used to create/edit a physical interface."""

    enabled = forms.NullBooleanField(required=False)

    class Meta:
        model = PhysicalInterface
        fields = InterfaceForm.Meta.fields + (
            'mac_address',
            'name',
            'enabled',
        )

    def __init__(self, *args, **kwargs):
        super(PhysicalInterfaceForm, self).__init__(*args, **kwargs)
        # Force MAC to be non-null.
        self.fields['mac_address'].required = True
        # Allow the name to be auto-generated if missing.
        self.fields['name'].required = False

    def clean_parents(self):
        parents = self.get_clean_parents()
        if parents is None:
            return
        if len(parents) > 0:
            raise ValidationError("A physical interface cannot have parents.")

    def clean(self):
        cleaned_data = super(PhysicalInterfaceForm, self).clean()
        new_name = cleaned_data.get('name')
        if self.fields_ok(['name']):
            if new_name:
                self.clean_interface_name_uniqueness(new_name)
            elif not new_name and self.instance.id is None:
                # No name provided and new instance. Auto-generate the name.
                cleaned_data['name'] = self.node.get_next_ifname()
        return cleaned_data
Пример #18
0
class PrefixBulkEditForm(BootstrapMixin, AddRemoveTagsForm,
                         CustomFieldBulkEditForm):
    pk = forms.ModelMultipleChoiceField(queryset=Prefix.objects.all(),
                                        widget=forms.MultipleHiddenInput())
    site = forms.ModelChoiceField(queryset=Site.objects.all(),
                                  required=False,
                                  widget=APISelect(api_url="/api/dcim/sites/"))
    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(),
                                 required=False,
                                 label='VRF',
                                 widget=APISelect(api_url="/api/ipam/vrfs/"))
    prefix_length = forms.IntegerField(min_value=PREFIX_LENGTH_MIN,
                                       max_value=PREFIX_LENGTH_MAX,
                                       required=False)
    tenant = forms.ModelChoiceField(
        queryset=Tenant.objects.all(),
        required=False,
        widget=APISelect(api_url="/api/tenancy/tenants/"))
    status = forms.ChoiceField(choices=add_blank_choice(PrefixStatusChoices),
                               required=False,
                               widget=StaticSelect2())
    role = forms.ModelChoiceField(queryset=Role.objects.all(),
                                  required=False,
                                  widget=APISelect(api_url="/api/ipam/roles/"))
    is_pool = forms.NullBooleanField(required=False,
                                     widget=BulkEditNullBooleanSelect(),
                                     label='Is a pool')
    description = forms.CharField(max_length=100, required=False)

    class Meta:
        nullable_fields = [
            'site',
            'vrf',
            'tenant',
            'role',
            'description',
        ]
Пример #19
0
class DirectPeeringSessionBulkEditForm(BootstrapMixin, AddRemoveTagsForm,
                                       BulkEditForm):
    pk = DynamicModelMultipleChoiceField(
        queryset=DirectPeeringSession.objects.all(),
        widget=forms.MultipleHiddenInput)
    enabled = forms.NullBooleanField(required=False,
                                     label="Enable",
                                     widget=CustomNullBooleanSelect)
    relationship = forms.ChoiceField(
        required=False,
        choices=add_blank_choice(BGPRelationship.choices),
        widget=StaticSelect,
    )
    bgp_group = DynamicModelChoiceField(required=False,
                                        queryset=BGPGroup.objects.all(),
                                        label="BGP Group")
    import_routing_policies = DynamicModelMultipleChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.all(),
        query_params={"type": "import-policy"},
    )
    export_routing_policies = DynamicModelMultipleChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.all(),
        query_params={"type": "export-policy"},
    )
    router = DynamicModelChoiceField(required=False,
                                     queryset=Router.objects.all())
    comments = CommentField()

    class Meta:
        nullable_fields = [
            "import_routing_policies",
            "export_routing_policies",
            "router",
            "comments",
        ]
Пример #20
0
class DisciplinaryActionForm(forms.ModelForm):
    CHOICES = (
        ('1', 'Yes'),
        ('0', 'No'),
    )
    disciplinary_action = forms.NullBooleanField(widget=forms.RadioSelect(
        choices=CHOICES, renderer=HorizontalRadioRenderer))
    disciplinary_action_reason = forms.CharField(required=False)

    class Meta:
        model = ApplicationFormDisciplinaryAction
        fields = ('disciplinary_action', )

    def clean(self):
        msg = "Please choose either yes or no"
        try:
            disciplinary_action = selfdata['disciplinary_action']
        except:
            disciplinary_action = self.cleaned_data['disciplinary_action']
        if disciplinary_action is None:
            self.add_error('disciplinary_action', msg)

    def save(self, commit=True):
        reason = self.cleaned_data['disciplinary_action_reason']
        disciplinary_action = super(DisciplinaryActionForm,
                                    self).save(commit=False)
        userprofile = UserProfile.objects.latest('id')
        disciplinary_action.user = userprofile
        reasons = Reasons.objects.get_or_create(reason=reason)
        if reasons:
            reasons = Reasons.objects.get(reason=reason)
        disciplinary_action.disciplinary_action_reason = reasons
        disciplinary_action.save()
        self.cleaned_data['user'] = userprofile
        self.cleaned_data['disciplinary_action_reason'] = reasons
        value = self.cleaned_data
        DisciplinaryAction.objects.create(**value)
Пример #21
0
class NullBooleanSelectForm(forms.Form, BaseFormFieldPluginForm):
    """
    Form for ``NullBooleanSelectPlugin``.
    """
    plugin_data_fields = [
        ("label", ""),
        ("name", ""),
        ("help_text", ""),
        ("initial", ""),
        ("required", False)
    ]

    label = forms.CharField(
        label = _("Label"),
        required = True,
        widget = forms.widgets.TextInput(attrs={'class': theme.form_element_html_class})
        )
    name = forms.CharField(
        label = _("Name"),
        required = True,
        widget = forms.widgets.TextInput(attrs={'class': theme.form_element_html_class})
        )
    help_text = forms.CharField(
        label = _("Help text"),
        required = False,
        widget = forms.widgets.Textarea(attrs={'class': theme.form_element_html_class})
        )
    initial = forms.NullBooleanField(
        label = _("Initial"),
        required = False,
        widget = forms.widgets.NullBooleanSelect(attrs={'class': theme.form_element_checkbox_html_class})
        )
    required = forms.BooleanField(
        label = _("Required"),
        required = False,
        widget = forms.widgets.CheckboxInput(attrs={'class': theme.form_element_checkbox_html_class})
        )
Пример #22
0
class ThemeConfigurationForm(forms.Form):
    theme = forms.CharField(widget=forms.HiddenInput)
    just_selected = forms.NullBooleanField(widget=forms.HiddenInput,
                                           initial=False)

    def prepare_for_serialization(self, data):
        return data

    def recover_from_serialization(self, data):
        return data

    def save_to_tag(self):
        tc = ThemeController()
        data = self.prepare_for_serialization(self.cleaned_data.copy())
        tc.set_template_settings(data)

    @classmethod
    def load_from_tag(cls, theme_name=None, just_selected=False):
        data = json.loads(Tag.getTag('theme_template_control', default='{}'))
        if theme_name is None:
            tc = ThemeController()
            theme_name = tc.get_current_theme()
        data['theme'] = theme_name
        form_temp = cls(initial=data)
        data = form_temp.recover_from_serialization(data)
        data['just_selected'] = just_selected
        form = cls(initial=data)
        return form

    @classmethod
    def initial_data(cls):
        """
        A dictionary of the initial values of the configuration form fields.
        """
        return dict(
            map(lambda (k, v): (k, v.initial),
                cls().fields.iteritems()))
Пример #23
0
class InternetExchangeBulkEditForm(BootstrapMixin, AddRemoveTagsForm,
                                   BulkEditForm):
    pk = DynamicModelMultipleChoiceField(
        queryset=InternetExchange.objects.all(),
        widget=forms.MultipleHiddenInput)
    local_autonomous_system = DynamicModelChoiceField(
        required=False,
        queryset=AutonomousSystem.objects.all(),
        query_params={"affiliated": True},
        label="Local Autonomous System",
    )
    import_routing_policies = DynamicModelMultipleChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.all(),
        query_params={"type": "import-policy"},
    )
    export_routing_policies = DynamicModelMultipleChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.all(),
        query_params={"type": "export-policy"},
    )
    communities = DynamicModelMultipleChoiceField(
        required=False, queryset=Community.objects.all())
    check_bgp_session_states = forms.NullBooleanField(
        required=False, label="Poll BGP State", widget=CustomNullBooleanSelect)
    router = DynamicModelChoiceField(required=False,
                                     queryset=Router.objects.all())
    comments = CommentField(widget=SmallTextarea)

    class Meta:
        nullable_fields = [
            "import_routing_policies",
            "export_routing_policies",
            "communities",
            "router",
            "comments",
        ]
Пример #24
0
class TalkActionForm(forms.Form):
    EMAIL_TALKS = 1
    EMAIL_SPEAKERS = 2
    EMAIL_CHOICES = (
        (None, "---------"),
        (EMAIL_TALKS, _('one per speaker and talk combination')),
        (EMAIL_SPEAKERS, _('only one per speaker')),
    )

    talks = forms.MultipleChoiceField(choices=[])
    decision = forms.NullBooleanField(label=_('Accept talk?'))
    track = forms.ChoiceField(required=False,
                              choices=[],
                              label=_('Assign to a track'))
    tag = forms.ChoiceField(required=False, choices=[], label=_('Add a tag'))
    room = forms.ChoiceField(required=False,
                             choices=[],
                             label=_('Put in a room'))
    email = forms.ChoiceField(required=False,
                              choices=EMAIL_CHOICES,
                              label=_('Send an email'))

    def __init__(self, *args, **kwargs):
        site = kwargs.pop('site')
        talks = kwargs.pop('talks')
        super().__init__(*args, **kwargs)
        self.fields['talks'].choices = [(talk.pk, None)
                                        for talk in talks.all()]
        tracks = Track.objects.filter(site=site)
        self.fields['track'].choices = [(None, "---------")] + list(
            tracks.values_list('slug', 'name'))
        tags = Tag.objects.filter(site=site)
        self.fields['tag'].choices = [(None, "---------")] + list(
            tags.values_list('slug', 'name'))
        rooms = Room.objects.filter(site=site)
        self.fields['room'].choices = [(None, "---------")] + list(
            rooms.values_list('slug', 'name'))
Пример #25
0
class ChargedOffenseForm(forms.ModelForm):
    CHOICES = (
        ('1', 'Yes'),
        ('0', 'No'),
    )
    charged_offense = forms.NullBooleanField(widget=forms.RadioSelect(
        choices=CHOICES, renderer=HorizontalRadioRenderer))
    charged_offense_reason = forms.CharField(required=False)

    class Meta:
        model = ApplicationFormChargedOffense
        fields = ('charged_offense', )

    def clean(self):
        msg = "Please choose either yes or no"
        try:
            charged_offense = selfdata['charged_offense']
        except:
            charged_offense = self.cleaned_data['charged_offense']
        if charged_offense is None:
            self.add_error('charged_offense', msg)

    def save(self, commit=True):
        reason = self.cleaned_data['charged_offense_reason']
        charged_offense = super(ChargedOffenseForm, self).save(commit=False)
        userprofile = UserProfile.objects.latest('id')
        charged_offense.user = userprofile
        reasons = Reasons.objects.get_or_create(reason=reason)
        if reasons:
            reasons = Reasons.objects.get(reason=reason)
        charged_offense.charged_offense_reason = reasons
        charged_offense.save()
        self.cleaned_data['user'] = userprofile
        self.cleaned_data['charged_offense_reason'] = reasons
        value = self.cleaned_data
        ChargedOffense.objects.create(**value)
Пример #26
0
class DirectPeeringSessionBulkEditForm(BootstrapMixin, BulkEditForm):
    pk = FilterChoiceField(queryset=DirectPeeringSession.objects.all(),
                           widget=forms.MultipleHiddenInput)
    enabled = forms.NullBooleanField(required=False,
                                     widget=CustomNullBooleanSelect,
                                     label="Enable")
    import_routing_policies = FilterChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.filter(
            Q(type=ROUTING_POLICY_TYPE_IMPORT)
            | Q(type=ROUTING_POLICY_TYPE_IMPORT_EXPORT)),
    )
    export_routing_policies = FilterChoiceField(
        required=False,
        queryset=RoutingPolicy.objects.filter(
            Q(type=ROUTING_POLICY_TYPE_EXPORT)
            | Q(type=ROUTING_POLICY_TYPE_IMPORT_EXPORT)),
    )
    router = forms.ModelChoiceField(required=False,
                                    queryset=Router.objects.all())
    comment = CommentField()

    class Meta:
        nullable_fields = ["router", "comment"]
Пример #27
0
    def formfield(self, **kwargs):
        """
        Get a form field for this attribute.

        :param kwargs: Kwargs to pass for the form field class.
        :return: Form field.
        :rtype: forms.Field
        """
        kwargs.setdefault("required", False)
        kwargs.setdefault(
            "label", self.safe_translation_getter("name", self.identifier))
        if self.type == AttributeType.INTEGER:
            return forms.IntegerField(**kwargs)
        elif self.type == AttributeType.DECIMAL:
            return forms.DecimalField(**kwargs)
        elif self.type == AttributeType.BOOLEAN:
            return forms.NullBooleanField(**kwargs)
        elif self.type == AttributeType.TIMEDELTA:
            kwargs.setdefault("help_text", "(as seconds)")
            # TODO: This should be more user friendly
            return forms.DecimalField(**kwargs)
        elif self.type == AttributeType.DATETIME:
            return forms.DateTimeField(**kwargs)
        elif self.type == AttributeType.DATE:
            return forms.DateField(**kwargs)
        elif self.type == AttributeType.UNTRANSLATED_STRING:
            return forms.CharField(**kwargs)
        elif self.type == AttributeType.TRANSLATED_STRING:
            # Note: this isn't enough for actually saving multi-language entries;
            #       the caller will have to deal with calling this function several
            #       times for that.
            return forms.CharField(**kwargs)
        else:
            raise ValueError(
                "Error! `formfield` can't deal with the fields of type `%r`." %
                self.type)
Пример #28
0
class FormField(forms.Form):
    # python data type
    integer_field = forms.IntegerField(required=False)
    decimal_field = forms.DecimalField(required=False)
    float_field = forms.FloatField(required=False)
    boolean_field = forms.BooleanField(required=False)
    char_field = forms.CharField(max_length=10, required=False)

    # string input
    email_field = forms.EmailField(required=False)
    regex_field = forms.RegexField(regex=r'(P?<test>)')
    slug_field = forms.SlugField()
    url_field = forms.URLField()
    ip_field = forms.GenericIPAddressField()

    # select input
    PILIHAN = (
        ('nilai1', 'Pilihan1'),
        ('nilai2', 'Pilihan2'),
        ('nilai3', 'Pilihan3'),
    )
    choice_field = forms.ChoiceField(choices=PILIHAN)
    multi_choice_field = forms.MultipleChoiceField(choices=PILIHAN)
    multi_typed_field = forms.TypedMultipleChoiceField(choices=PILIHAN)
    null_boolean_field = forms.NullBooleanField()

    # date time
    date_field = forms.DateField()
    datetime_field = forms.DateTimeField()
    duration_field = forms.DurationField()
    time_field = forms.TimeField()
    splidatetime_field = forms.SplitDateTimeField()

    # file input
    file_field = forms.FileField()
    image_field = forms.ImageField()
Пример #29
0
class ManyFieldsExampleForm(forms.Form):
    hiddeninput = forms.CharField(widget=forms.HiddenInput())
    multiplehiddeninput = forms.MultipleChoiceField(
        widget=forms.MultipleHiddenInput, choices=CONTINENTS)
    modelchoicefield = forms.ModelChoiceField(queryset=Friend.objects.all(),
                                              empty_label="Empty Space",
                                              to_field_name="first_name")
    modelchoicefield2 = forms.ModelChoiceField(queryset=Friend.objects.all(),
                                               to_field_name="first_name")
    modelmultiplechoicefield = forms.ModelMultipleChoiceField(
        queryset=Friend.objects.all())
    booleanfield = forms.BooleanField(label="BooleanField")
    charfield = forms.CharField(label="CharField")
    choicefield = forms.ChoiceField(label="ChoiceField", choices=CONTINENTS)
    typedchoicefield = forms.TypedChoiceField(label="TypedChoiceField")
    datefield = forms.DateField(label="DateField")
    datetimefield = forms.DateTimeField(label="DateTimeField")
    decimalfield = forms.DecimalField(label="DecimalField")
    durationfield = forms.DurationField(label="DurationField")
    emailfield = forms.EmailField(label="EmailField")
    filefield = forms.FileField(label="FileField")
    filepathfield = forms.FilePathField(label="FilePathField", path="/")
    floatfield = forms.FloatField(label="FloatField")
    imagefield = forms.ImageField(label="ImageField")
    integerfield = forms.IntegerField(label="IntegerField")
    genericipaddressfield = forms.GenericIPAddressField(
        label="GenericIPAddressField")
    multiplechoicefield = forms.MultipleChoiceField(
        label="MultipleChoiceField", choices=CONTINENTS)
    typedmultiplechoicefield = forms.TypedMultipleChoiceField(
        label="TypedMultipleChoiceField", choices=CONTINENTS)
    nullbooleanfield = forms.NullBooleanField(label="NullBooleanField")
    slugfield = forms.SlugField(label="SlugField")
    timefield = forms.TimeField(label="TimeField")
    urlfield = forms.URLField(label="URLField")
    uuidfield = forms.UUIDField(label="UUIDField")
Пример #30
0
class RoleDetail(BaseView):
    @cms_auth
    @validate_args({
        'role_id': forms.IntegerField(),
    })
    @fetch_object(CMSRole.objects, 'role')
    @cms_permission_role()
    def get(self, request, role, **kwargs):
        return self.success(role_to_json(role))

    @cms_auth
    @cms_permission('updateRoleInfo')
    @validate_args({
        'role_id': forms.IntegerField(),
        'name': forms.CharField(max_length=100, required=False),
        'category': forms.CharField(max_length=100, required=False),
        'enable': forms.NullBooleanField(required=False),
    })
    @fetch_object(CMSRole.objects, 'role')
    @cms_permission_role()
    def post(self, request, role, **kwargs):
        '''
        更新角色信息,要求有权限,且必须是我的下级角色
        :param request:
        :param role:
        :param kwargs:
        :return:
        '''
        params_list = ['name', 'category', 'enable']
        update_param = {}
        for p in params_list:
            if p in kwargs:
                update_param[p] = kwargs[p]
        if len(update_param) > 0:
            CMSRole.objects.filter(id=role.id).update(**update_param)
        return self.success()