def test_multiplechoicefield_changed(self):
     f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two'), ('3', 'Three')])
     self.assertFalse(f.has_changed(None, None))
     self.assertFalse(f.has_changed([], None))
     self.assertTrue(f.has_changed(None, ['1']))
     self.assertFalse(f.has_changed([1, 2], ['1', '2']))
     self.assertFalse(f.has_changed([2, 1], ['1', '2']))
     self.assertTrue(f.has_changed([1, 2], ['1']))
     self.assertTrue(f.has_changed([1, 2], ['1', '3']))
class PreSelectedModelSearchForm(ModelSearchForm):
    possible_facets = MultipleChoiceField(widget=CheckboxSelectMultiple,
                                          choices=(),
                                          required=False,
                                          label=_("Finding facets on"))
    search_type = ChoiceField(choices=[(0, "Autoquery"), (1, "Exact")],
                              required=False,
                              initial=0,
                              label=_("Search type"))
    content_field = ChoiceField(choices=(),
                                required=False,
                                label=_("Indexed fields"))
    connection = ChoiceField(choices=(), required=False)
    p = IntegerField(required=False,
                     label=_("Page"),
                     min_value=0,
                     max_value=99999999,
                     initial=1)

    def __init__(self, *args, **kwargs):
        """
        If we're in a recognised faceting engine, display and allow faceting.
        """
        super(PreSelectedModelSearchForm, self).__init__(*args, **kwargs)
        if 'models' in self.fields:
            self.fields['models'].initial = [x[0] for x in model_choices()]
            self.fields['models'].label = _("Only models")
        self.haystack_config = HaystackConfig()

        self.fields['content_field'].choices = content_field_choices()

        self.version = self.haystack_config.version
        if self.should_allow_faceting():
            possible_facets = self.configure_faceting()
            self.fields['possible_facets'].choices = possible_facets
            self.fields['selected_facets'] = SelectedFacetsField(
                choices=(), required=False, possible_facets=possible_facets)

        if self.has_multiple_connections():
            wtf = self.get_possible_connections()
            self.fields['connection'].choices = tuple(wtf)  # noqa
            self.fields['connection'].initial = 'default'
        else:
            self.fields['connection'].widget = HiddenInput()

    def is_haystack1(self):
        return self.haystack_config.is_version_1x()

    def is_haystack2(self):
        return self.haystack_config.is_version_2x()

    def guess_haystack_version(self):
        return self.haystack_config.version

    def has_multiple_connections(self):
        return self.haystack_config.has_multiple_connections()

    def get_possible_connections(self):
        return self.haystack_config.get_connections()

    def configure_faceting(self):
        possible_facets = self.haystack_config.get_facets(
            sqs=self.searchqueryset)
        return [Facet(x).choices() for x in sorted(possible_facets)]

    def should_allow_faceting(self):
        return self.haystack_config.supports_faceting()

    def __repr__(self):
        is_valid = self.is_bound and not bool(self._errors)
        return '<%(module)s.%(cls)s bound=%(is_bound)s valid=%(valid)s ' \
               'version=%(version)d multiple_connections=%(conns)s ' \
               'supports_faceting=%(facets)s>' % {
                   'module': self.__class__.__module__,
                   'cls': self.__class__.__name__,
                   'is_bound': yesno(self.is_bound),
                   'conns': yesno(self.has_multiple_connections()),
                   'facets': yesno(self.should_allow_faceting()),
                   'valid': yesno(is_valid),
                   'version': self.haystack_config.version,
               }

    def no_query_found(self):
        """
        When nothing is entered, show everything, because it's a better
        useful default for our usage.
        """
        return self.searchqueryset.all()

    def search(self):
        sqs = self.searchqueryset.all()

        if not self.is_valid():
            # When nothing is entered, show everything, because it's a better
            # useful default for our usage.
            return sqs

        cleaned_data = getattr(self, 'cleaned_data', {})

        connection = cleaned_data.get('connection', ())
        if self.has_multiple_connections() and len(connection) == 1:
            sqs = sqs.using(*connection)

        if self.should_allow_faceting():
            for applied_facet in self.applied_facets():
                narrow_query = applied_facet.narrow.format(
                    cleaned_value=sqs.query.clean(applied_facet.value))
                sqs = sqs.narrow(narrow_query)

            to_facet_on = sorted(cleaned_data.get('possible_facets', ()))
            if len(to_facet_on) > 0:
                for field in to_facet_on:
                    sqs = sqs.facet(field)

        only_models = self.get_models()
        if len(only_models) > 0:
            sqs = sqs.models(*only_models)

        content_field = cleaned_data.get('content_field', ['content'])

        query = cleaned_data.get('q', None)
        if query and query[0]:
            if cleaned_data.get("search_type", 0) == "1":
                kwargs = {content_field[0]: Exact(*query)}
                sqs = sqs.filter(**kwargs)
            else:
                sqs = sqs.auto_query(*query, fieldname=content_field[0])

        if self.load_all:
            sqs = sqs.load_all()

        return sqs

    def clean_connection(self):
        return [self.cleaned_data.get('connection', 'default').strip()]

    def clean_possible_facets(self):
        return list(frozenset(self.cleaned_data.get('possible_facets', ())))

    def clean_selected_facets(self):
        return list(frozenset(self.cleaned_data.get('selected_facets', ())))

    def clean_q(self):
        return [self.cleaned_data.get('q', '')]

    def clean_content_field(self):
        return [self.cleaned_data.get('content_field', '')]

    def clean_p(self):
        page = self.cleaned_data.get('p', None)
        if page is None:
            page = self.fields['p'].min_value
        return [page]

    def full_clean(self):
        """
        Taken from Django master as of 5e06fa1469180909c51c07151692412269e51ea3
        but is mostly a copy-paste all the way back to 1.3.1
        Basically we want to keep cleaned_data around, not remove it
        if errors occured.
        """
        self._errors = ErrorDict()
        if not self.is_bound:  # Stop further processing.
            return
        self.cleaned_data = {}
        # If the form is permitted to be empty, and none of the form data has
        # changed from the initial data, short circuit any validation.
        if self.empty_permitted and not self.has_changed():
            return
        self._clean_fields()
        self._clean_form()
        self._post_clean()

    def clean(self):
        cd = self.cleaned_data
        selected = 'selected_facets'
        possible = 'possible_facets'
        if selected in cd and len(cd[selected]) > 0:
            if possible not in cd or len(cd[possible]) == 0:
                raise ValidationError(
                    'Unable to provide facet counts without selecting a field to facet on'
                )
        return cd

    def applied_facets(self):
        cleaned_querydict = self.cleaned_data_querydict
        return AppliedFacets(querydict=cleaned_querydict)

    @property
    def cleaned_data_querydict(self):
        """
        Creates an immutable QueryDict instance from the form's cleaned_data
        """
        query = QueryDict('', mutable=True)
        # make sure cleaned_data is available, if possible ...
        self.is_valid()
        cleaned_data = getattr(self, 'cleaned_data', {})
        for key, values in cleaned_data.items():
            query.setlist(key=key, list_=values)
        query._mutable = False
        return query
Beispiel #3
0
 def check_for_widget(self, widget, field):
     if widget:
         for field_to_set_widget, widget in widget.items():
             if field_to_set_widget == field:
                 return (True, widget, MultipleChoiceField().__class__)
Beispiel #4
0
 def test_disabled_has_changed(self):
     f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')], disabled=True)
     self.assertIs(f.has_changed('x', 'y'), False)
Beispiel #5
0
 def test_multiplechoicefield_3(self):
     f = MultipleChoiceField(
         choices=[('Numbers', (('1', 'One'), ('2', 'Two'))), ('Letters', (('3', 'A'), ('4', 'B'))), ('5', 'Other')]
     )
     self.assertEqual(['1'], f.clean([1]))
     self.assertEqual(['1'], f.clean(['1']))
     self.assertEqual(['1', '5'], f.clean([1, 5]))
     self.assertEqual(['1', '5'], f.clean([1, '5']))
     self.assertEqual(['1', '5'], f.clean(['1', 5]))
     self.assertEqual(['1', '5'], f.clean(['1', '5']))
     msg = "'Select a valid choice. 6 is not one of the available choices.'"
     with self.assertRaisesMessage(ValidationError, msg):
         f.clean(['6'])
     msg = "'Select a valid choice. 6 is not one of the available choices.'"
     with self.assertRaisesMessage(ValidationError, msg):
         f.clean(['1', '6'])
Beispiel #6
0
class ButtonMenuEditForm(CremeForm):
    # TODO: use EnhancedMultipleChoiceField + description of the button as help text ?
    button_ids = MultipleChoiceField(
        label=_('Buttons to display'), required=False,
        choices=(), widget=ButtonMenuEditionWidget,
        help_text=_("Drag and drop the buttons between the available buttons and "
                    "the selected buttons sections to enable or disable the buttons, "
                    "or within the selected buttons section to change the order.")
    )

    def __init__(self, button_menu_items, ct_id, button_registry=None, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.ct = ContentType.objects.get_for_id(ct_id) if ct_id else None
        self.set_buttons = button_menu_items

        button_registry = button_registry or button_menu.button_registry
        choices = []

        if not self.ct:  # Default conf
            choices.extend(
                (id_, button)
                for id_, button in button_registry
                if not button.get_ctypes()
            )
        else:
            model_class = self.ct.model_class()

            default_conf_ids = frozenset(
                ButtonMenuItem.objects
                              .filter(content_type=None)
                              .values_list('button_id', flat=True)
            )

            for id_, button in button_registry:
                ctypes = button.get_ctypes()

                if not ctypes:
                    if id_ not in default_conf_ids:
                        choices.append((id_, button))
                elif model_class in ctypes:
                    choices.append((id_, button))

        sort_key = collator.sort_key
        choices.sort(key=lambda c: sort_key(str(c[1].verbose_name)))

        button_ids = self.fields['button_ids']
        button_ids.choices = choices
        button_ids.initial = [bmi.button_id for bmi in button_menu_items]

    def save(self):
        button_ids = self.cleaned_data['button_ids']
        ct = self.ct
        BMI_objects = ButtonMenuItem.objects
        BMI_get = BMI_objects.get

        if not button_ids:
            # No pk to BMI objects --> can delete() on queryset directly
            BMI_objects.filter(content_type=ct).delete()
            # No button for this content type -> fake button_id
            ButtonMenuItem.objects.create(content_type=ct, button_id='', order=1)
        else:
            old_ids = {bmi.button_id for bmi in self.set_buttons}
            new_ids = {*button_ids}
            buttons_2_del = old_ids - new_ids
            buttons_2_add = new_ids - old_ids

            # No pk to BCI objects --> can delete() on queryset directly
            BMI_objects.filter(content_type=ct, button_id__in=buttons_2_del).delete()

            offset = 1 if ct is None else 1000  # Default conf before ct's conf

            for i, button_id in enumerate(button_ids):
                if button_id in buttons_2_add:
                    ButtonMenuItem.objects.create(
                        content_type=ct, button_id=button_id, order=i + offset,
                    )
                else:
                    bmi = BMI_get(content_type=ct, button_id=button_id)

                    if bmi.order != i + offset:
                        bmi.order = i + offset
                        bmi.save()
Beispiel #7
0
class BulkCopyIndicatorsForm(forms.Form):
    destination_domain = forms.CharField(label="Destination Project Space")
    indicator_ids = MultipleChoiceField(
        label="Indicator(s)",
        validators=[MinLengthValidator(1)])

    def __init__(self, domain=None, couch_user=None, indicator_class=None, *args, **kwargs):
        super(BulkCopyIndicatorsForm, self).__init__(*args, **kwargs)
        self.domain = domain
        self.couch_user = couch_user
        self.indicator_class = indicator_class

        self.fields['destination_domain'].widget = forms.Select(choices=[(d, d) for d in self.available_domains])
        self.fields['indicator_ids'].choices = self.available_indicators

        self.helper = FormHelper()
        self.helper.label_class = 'col-sm-3'
        self.helper.field_class = 'col-sm-9'

    @property
    @memoized
    def available_domains(self):
        if not self.couch_user:
            return []
        indicator_domains = set(get_indicator_domains())
        indicator_domains = indicator_domains.difference([self.domain])
        return [d for d in indicator_domains if self.couch_user.has_permission(d, Permissions.edit_data)]

    @property
    @memoized
    def available_indicators(self):
        indicators = []
        for namespace in get_namespaces(self.domain):
            indicators.extend(self.indicator_class.get_all_of_type(namespace, self.domain))
        return [(i._id, "%s | v. %d | n: %s" % (i.slug, i.version if i.version else 0,
                                                get_namespace_name(i.domain, i.namespace))) for i in indicators]

    def clean_destination_domain(self):
        if 'destination_domain' in self.cleaned_data:
            destination = self.cleaned_data['destination_domain']
            if not self.couch_user or not self.couch_user.has_permission(destination, Permissions.edit_data):
                raise ValidationError("You do not have permission to copy indicators to this project space.")
            if destination not in self.available_domains:
                raise ValidationError("You submitted an invalid destination project space")
            return destination

    def copy_indicators(self):
        failed = []
        success = []
        destination_domain = self.cleaned_data['destination_domain']
        available_namespaces = get_namespaces(destination_domain)
        indicator_ids = self.cleaned_data['indicator_ids']
        for indicator_id in indicator_ids:
            try:
                indicator = self.indicator_class.get(indicator_id)
                properties_to_exclude = [
                    'last_modified',
                    'base_doc',
                    'namespace',
                    'domain',
                    'class_path',
                    'version'
                ]
                if indicator.namespace not in available_namespaces:
                    failed.append(dict(indicator=indicator.slug,
                                       reason='Indicator namespace not available for destination project.'))
                    continue

                properties = set(indicator.properties().keys())
                copied_properties = properties.difference(properties_to_exclude)
                copied_properties = dict([(p, getattr(indicator, p)) for p in copied_properties])

                copied_indicator = self.indicator_class.increment_or_create_unique(
                    indicator.namespace,
                    destination_domain,
                    **copied_properties
                )
                if copied_indicator:
                    success.append(copied_indicator.slug)

            except Exception as e:
                failed.append(dict(indicator=indicator_id,
                                   reason='Could not retrieve indicator %s due to error %s:' % (indicator_id, e)))
        return {
            'success': success,
            'failure': failed,
        }
Beispiel #8
0
 def __init__(self, *args, **kwargs):
     self.question = kwargs.pop("question", None)
     self.department = kwargs.pop("department", None)
     self.survey = kwargs.pop("survey", None)
     super().__init__(*args, **kwargs)
     options = [(o.id, o.text) for o in self.question.options()]
     self.field_name = f"option"
     self.option_field = False
     if self.question.qtype == "MULTICHOICE":
         self.single = False
         self.option_field = True
         self.fields[self.field_name] = MultipleChoiceField(
             label=self.question.text,
             choices=options,
             widget=forms.CheckboxSelectMultiple(),
             required=False,
         )
     elif self.question.qtype == "SINGLECHOICE":
         self.single = True
         self.option_field = True
         self.fields[self.field_name] = ChoiceField(
             label=self.question.text,
             choices=options,
             widget=forms.RadioSelect(),
             required=False,
         )
     elif self.question.qtype == "SELECT":
         self.single = True
         self.option_field = True
         self.fields[self.field_name] = ChoiceField(
             label=self.question.text,
             choices=options,
             required=False,
         )
     elif self.question.qtype == "TEXT":
         self.single = True
         self.fields[self.field_name] = CharField(
             label=self.question.text,
             required=False,
         )
     elif self.question.qtype == "ESSAY":
         self.single = True
         self.fields[self.field_name] = CharField(
             label=self.question.text,
             widget=forms.Textarea,
             required=False,
         )
     elif self.question.qtype == "INTEGER":
         self.single = True
         self.fields[self.field_name] = IntegerField(
             label=self.question.text,
             required=False,
         )
     elif self.question.qtype == "EMAIL":
         self.single = True
         self.fields[self.field_name] = EmailField(
             label=self.question.text,
             required=False,
         )
     else:
         raise AttributeError("Bad field type")
     self.fields["qid"] = forms.CharField(
         label="qid", max_length=10, widget=forms.HiddenInput()
     )
     self.fields[self.field_name].help_text = self.question.help_text
Beispiel #9
0
class SearchForm(Form):
    q = CharField(initial='',
                  widget=TextInput(
                      attrs={
                          'id': 'search',
                          'class': 'form-control',
                          'autofocus': True,
                          'placeholder': "Search in record and full text"
                      }))
    type = MultipleChoiceField(choices=defs.DOC_TYPE)

    tr_type_of_document = MultipleChoiceField()
    tr_field_of_application = MultipleChoiceField()
    tr_status = MultipleChoiceField()
    tr_place_of_adoption = MultipleChoiceField()
    tr_depository = MultipleChoiceField()

    dec_type_of_document = MultipleChoiceField()
    dec_status = MultipleChoiceField()
    dec_treaty_name = MultipleChoiceField()

    cd_type_of_document = MultipleChoiceField()
    cd_territorial_subdivision = MultipleChoiceField()

    lit_type_of_text = MultipleChoiceField()
    lit_author = MultipleChoiceField()
    lit_orig_serial_title = MultipleChoiceField()
    lit_publisher = MultipleChoiceField()

    leg_type_of_document = MultipleChoiceField()
    leg_territorial_subdivision = MultipleChoiceField()
    leg_status = MultipleChoiceField()

    xsubjects = MultipleChoiceField()
    xkeywords = MultipleChoiceField()
    xcountry = MultipleChoiceField()
    xregion = MultipleChoiceField()
    xlanguage = MultipleChoiceField()
    yearmin = CharField()
    yearmax = CharField()

    sortby = CharField(initial='')

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)

        # add AND-able fields
        for f in defs._AND_OP_FACETS:
            fname = self.get_and_field_name_for(f)
            self.fields[fname] = BooleanField()

        # no field is required
        for field in self.fields.values():
            field.required = False

    @staticmethod
    def get_and_field_name_for(field):
        return defs._AND_OP_FIELD_PATTERN % field

    def _has_document_type(self, doctype):
        return doctype in self.data.get('type', [])

    def has_treaty(self):
        return self._has_document_type('treaty')

    def has_decision(self):
        return self._has_document_type('decision')

    def has_literature(self):
        return self._has_document_type('literature')

    def has_legislation(self):
        return self._has_document_type('legislation')

    def has_court_decision(self):
        return self._has_document_type('court_decision')
Beispiel #10
0
class _ExampleForm(Form):
    single = ChoiceField(choices=((1, "one"), (2, "two"), (3, "three")), required=False)
    multi = MultipleChoiceField(
        choices=((1, "one"), (2, "two"), (3, "three"), (4, "four"), (5, "five")),
        required=False,
    )
Beispiel #11
0
    threshold       = ChoiceField(choices=[(25,25),(90,90)], required=False)
    resolutionMin   = FloatField(required=False, min_value=0, initial=0, widget=TextInput(attrs={'size':3}))
    resolutionMax   = FloatField(required=False, min_value=0, initial=1.2, widget=TextInput(attrs={'size':3}))
    rfactorMin      = FloatField(required=False, min_value=0, initial=0, widget=TextInput(attrs={'size':3}))
    rfactorMax      = FloatField(required=False, min_value=0, initial=0.25, widget=TextInput(attrs={'size':3}))
    rfreeMin        = FloatField(required=False, min_value=0, initial=0, widget=TextInput(attrs={'size':3}))
    rfreeMax        = FloatField(required=False, min_value=0, initial=0.30, widget=TextInput(attrs={'size':3}))
    proteins        = CharField(required=False)
    proteins_i      = IntegerField(required=False, widget=HiddenInput(attrs={'class':'include'}))
    residues        = ChoiceField(choices=[(i,i) for i in range(1, settings.SEGMENT_SIZE+1)], initial=3)

# Build a dict for the fields of variable number
form_dict = {'__module__' : 'pgd_search.views'}

for i in RESIDUE_INDEXES:
    form_dict["aa_%i" % i]      = MultipleChoiceField(choices=AA_CHOICES, required=False, widget=SelectMultiple(attrs={'class':'field'}))
    form_dict["aa_i_%i" % i]    = IntegerField(required=False, widget=HiddenInput(attrs={'class':'include'}))

    form_dict["ss_%i" % i]      = MultipleChoiceField(choices=SS_CHOICES, required=False, widget=SelectMultiple(attrs={'class':'field'}))
    form_dict["ss_i_%i" % i]    = IntegerField(required=False, widget=HiddenInput(attrs={'class':'include'}))

    # the loops here are just to save on space/typing
    for j in range(1,8):   # Angles
        form_dict["a%i_%i" % (j,i)]     = SearchSyntaxField(required=False, widget=TextInput(attrs={'class':'field needs_reset', 'size':8}))
        form_dict["a%i_i_%i" % (j,i)]   = IntegerField(required=False, widget=HiddenInput(attrs={'class':'include'}))
    for j in range(1,6):   # Lengths
        form_dict["L%i_%i" % (j, i)]    = SearchSyntaxField(required=False, widget=TextInput(attrs={'class':'field needs_reset', 'size':8}))
        form_dict["L%i_i_%i" % (j, i)]  = IntegerField(required=False, widget=HiddenInput(attrs={'class':'include'}))
    for j in ("phi", "psi", "ome", "chi1","chi2","chi3","chi4",'chi5', "bm", "bs", "bg", "h_bond_energy", "zeta"):
        form_dict["%s_%i" % (j, i)]     = SearchSyntaxField(required=False, widget=TextInput(attrs={'class':'field needs_reset', 'size':8}))
        form_dict["%s_i_%i" % (j, i)]   = IntegerField(required=False, widget=HiddenInput(attrs={'class':'include'}))
Beispiel #12
0
class LogSearchForm(Form):
    class FormNotValid(StandardError):
        pass

    import logging

    #matrix parameters for call
    type = MultipleChoiceField(choices=(
        ('all', 'All'),
        ('DELETE_LIBRARY', 'DELETE_LIBRARY'),
        ('UPDATE_LIBRARY_ITEM_METADATA', 'UPDATE_LIBRARY_ITEM_METADATA'),
        ('NONE', 'NONE'),
        ('IMPORT', 'IMPORT'),
        ('TRANSCODE', 'TRANSCODE'),
        ('RAW_TRANSCODE', 'RAW_TRANSCODE'),
        ('CONFORM', 'CONFORM'),
        ('TRANSCODE_RANGE', 'TRANSCODE_RANGE'),
        ('PLACEHOLDER_IMPORT', 'PLACEHOLDER_IMPORT'),
        ('RAW_IMPORT', 'RAW_IMPORT'),
        ('THUMBNAIL', 'THUMBNAIL'),
        ('AUTO_IMPORT', 'AUTO_IMPORT'),
        ('EXPORT', 'EXPORT'),
        ('COPY_FILE', 'COPY_FILE'),
        ('DELETE_FILE', 'DELETE_FILE'),
        ('MOVE_FILE', 'MOVE_FILE'),
        ('ESSENCE_VERSION', 'ESSENCE_VERSION'),
        ('FCS_RESTORE', 'FCS_RESTORE'),
        ('TIMELINE', 'TIMELINE'),
        ('SHAPE_IMPORT', 'SHAPE_IMPORT'),
        ('LIST_ITEMS', 'LIST_ITEMS'),
        ('ANALYZE', 'ANALYZE'),
        ('SHAPE_UPDATE', 'SHAPE_UPDATE'),
        ('ARCHIVE', 'ARCHIVE'),
        ('RESTORE', 'RESTORE'),
        ('SIDECAR_IMPORT', 'SIDECAR_IMPORT'),
        ('TEST_TRANSFER', 'TEST_TRANSFER'),
    ),
                               widget=CheckboxSelectMultiple())
    state = MultipleChoiceField(
        choices=(
            ('all', 'All'),
            ('NONE', 'None'),
            ('READY', 'Ready'),
            ('STARTED', 'Started'),
            ('STARTED_ASYNCHRONOUS', 'Started Asynchronous'),
            ('STARTED_PARALLEL', 'Started in background'),
            ('STARTED_PARALLEL_ASYNCHRONOUS',
             'Started in background, asynchronous'),
            ('STARTED_SUBTASKS', 'Started and doing in multiple subtasks'),
            ('FINISHED', 'Completed'),
            ('FAILED_RETRY', 'Retrying'),
            ('FAILED_FATAL', 'Failed'),
            ('FAILED_TOTAL', 'Failed'),
            ('WAITING', 'Waiting'),  #see /job/{job-id}/problem
            ('DISAPPEARED', 'Disappeared, lost worker')),
        widget=CheckboxSelectMultiple())
    sort = ChoiceField(choices=(
        ('startTime', 'Start Time'),
        ('priority', 'Priority'),
        ('jobId', 'Job ID'),
        ('type', 'Type'),
        ('state', 'State'),
        ('user', 'User'),
    ),
                       widget=Select(attrs={'style': 'width: 98%'}))
    sortOrder = ChoiceField(
        choices=(
            ('desc', 'Descending'),
            ('asc', 'Ascending'),
        ),
        widget=RadioSelect(),
    )
    fromDate = DateField(label="Starting from",
                         widget=TextInput(attrs={'style': 'width: 60%'}))
    fromTime = TimeField(label="Starting from",
                         widget=TextInput(attrs={'style': 'width: 60%'}))

    toDate = DateField(label="Ending at",
                       widget=TextInput(attrs={'style': 'width: 60%'}))
    toTime = TimeField(label="Ending at",
                       widget=TextInput(attrs={'style': 'width: 60%'}))

    #Query parameters for call
    jobmetadata = CharField(max_length=32768, widget=Textarea, required=False)

    #my own params which will be put into the above
    fileNameContains = CharField(
        max_length=512,
        widget=TextInput(attrs={'style': 'width: 98%; visibility: hidden'}),
        required=False)

    columns = MultipleChoiceField(choices=(
        ('jobId', 'jobId'),
        ('status', 'status'),
        ('type', 'type'),
        ('started', 'started'),
        ('priority', 'priority'),
        ('itemid', 'itemid'),
        ('systemJobModule', 'systemJobModule'),
        ('systemJobInfo', 'systemJobInfo'),
        ('destinationStorageId', 'destinationStorageId'),
        ('bestEffortFilename', 'bestEffortFilename'),
        ('fileId', 'fileId'),
        ('replicatedFileIds', 'replicatedFileIds'),
        ('fileDeleted', 'fileDeleted'),
        ('fileStateOnFailure', 'fileStateOnFailure'),
        ('filePathMap', 'filePathMap'),
        ('replicatedFileInfo', 'replicatedFileInfo'),
        ('checkReplicatedFiles', 'checkReplicatedFiles'),
    ),
                                  widget=CheckboxSelectMultiple())

    def vidispine_query_url(self, base, page):
        from datetime import datetime
        import time
        import calendar

        if not self.is_valid():
            raise self.FormNotValid()

        #logger=self.logging.getLogger("LogSearchForm::vidispine_query_url")
        d = self.cleaned_data

        if page == 1:
            pagesetting = 0
        else:
            pagesetting = page * 100 - 100

        pagesettingready = str(pagesetting)

        matrixparams = ""
        if not 'all' in d['state']:
            matrixparams += ";state=" + ",".join(
                map(lambda x: urllib.quote_plus(x, safe=""), d['state']))
        if not 'all' in d['type']:
            matrixparams += ";type=" + ",".join(
                map(lambda x: urllib.quote_plus(x, safe=""), d['type']))
        matrixparams += ";number=100;first=" + pagesettingready + ";sort={0}%20{1}".format(
            urllib.quote_plus(d['sort'], safe=""), d['sortOrder'])
        queryparams = "?metadata=true"

        if d['fileNameContains']:
            queryparams += "&jobmetadata=" + urllib.quote_plus(
                "bestEffortFilename=*{0}*".format(d['fileNameContains']),
                safe="")

        if d['jobmetadata']:
            queryparams += "&jobmetadata=" + urllib.quote_plus(
                d['jobmetadata'], safe="")

        fromTime = datetime.combine(d['fromDate'], d['fromTime'])
        toTime = datetime.combine(d['toDate'], d['toTime'])
        queryparams += "&starttime-from=" + urllib.quote_plus(
            fromTime.strftime("%Y-%m-%dT%H:%M:%S.%f"), safe="")
        queryparams += "&starttime-to=" + urllib.quote_plus(
            toTime.strftime("%Y-%m-%dT%H:%M:%S.%f"), safe="")

        print "debug: vidispine_query_url is {0}".format(base + matrixparams +
                                                         queryparams)
        return base + matrixparams + queryparams
Beispiel #13
0
class IntegrationScaffoldingForm(Form):
    name = CharField(max_length=80,
                     label=_('Integration name'),
                     widget=TextInput())
    author_homepage = URLField(label=_('Author\'s homepage'), required=False)
    issue_tracker = URLField(label=_('Issue tracker URL'),
                             required=False,
                             help_text=_('Bug reports and feature requests'))
    categories = MultipleChoiceField(widget=HiddenInput(),
                                     disabled=True,
                                     required=True,
                                     label=_('Categories'),
                                     choices=lazy(get_categories, list),
                                     help_text=_('Hold down Ctrl and click to '
                                                 'select multiple entries'))
    summary = CharField(
        max_length=256,
        label=_('Summary'),
        help_text=
        _('Short description of your app that will be rendered as short teaser'
          ))
    screenshot = URLField(max_length=256,
                          label=_('Screenshot URL'),
                          required=False,
                          help_text=_('URL for integration screenshot'))
    screenshot_thumbnail = URLField(max_length=256,
                                    label=_('Screenshot '
                                            'thumbnail URL'),
                                    required=False,
                                    help_text=_('URL for integration '
                                                'screenshot in '
                                                'smaller dimensions. '
                                                'Must be used in combination '
                                                'with a larger screenshot.'))
    description = CharField(widget=Textarea,
                            label=_('Description'),
                            help_text=_('Full description of what your'
                                        ' integration '
                                        'does. Can contain Markdown.'))

    def _create_discourse_category(self, app_id: str) -> None:
        url = '%s/categories?api_key=%s&api_username=%s' % (
            settings.DISCOURSE_URL.rstrip('/'), settings.DISCOURSE_TOKEN,
            settings.DISCOURSE_USER)
        data = {
            'name': app_id.replace('_', '-'),
            'color': '3c3945',
            'text_color': 'ffffff'
        }
        if settings.DISCOURSE_PARENT_CATEGORY_ID:
            data['parent_category_id'] = settings.DISCOURSE_PARENT_CATEGORY_ID

        # ignore requests errors because there can be many issues and we do not
        # want to abort app registration just because the forum is down or
        # leak sensitive data like tokens or users
        try:
            requests.post(url, data=data)
        except requests.HTTPError:
            pass

    def save(self, user, app_id, action):
        if app_id is None:
            app_id = slugify(self.cleaned_data['name']).replace('-', '_')[:80]
        try:
            app = App.objects.get(id=app_id)
            if app.can_update(user) or user.is_superuser:
                if action == "reject" and user.is_superuser:
                    '''Not optimal but works'''
                    Screenshot.objects.filter(app=app).delete()
                    app.delete()
                elif action == "approve" and user.is_superuser:
                    app.approved = True
                    if settings.DISCOURSE_TOKEN:
                        self._create_discourse_category(app_id)
                    app.save()
                    return app_id
                else:
                    '''Not optimal but works'''
                    Screenshot.objects.filter(app=app).delete()
                    if self.data['screenshot']:
                        screenshot = Screenshot.objects.create(
                            url=self.cleaned_data['screenshot'],
                            small_thumbnail=self.
                            cleaned_data['screenshot_thumbnail'],
                            ordering=1,
                            app=app)
                        screenshot.save()

                    app.description = self.cleaned_data['description']
                    app.name = self.cleaned_data['name']
                    app.summary = self.cleaned_data['summary']
                    app.website = self.cleaned_data['author_homepage']
                    app.issue_tracker = self.cleaned_data['issue_tracker']
                    app.save()
                    return app_id
        except App.DoesNotExist:
            app = App.objects.create(id=app_id,
                                     owner=user,
                                     certificate=uuid.uuid1().urn)
            app.set_current_language('en')
            app.categories.set(self.cleaned_data['categories'])
            app.description = self.cleaned_data['description']
            app.name = self.cleaned_data['name']
            app.summary = self.cleaned_data['summary']
            app.website = self.cleaned_data['author_homepage']
            app.issue_tracker = self.cleaned_data['issue_tracker']
            app.save()
            p = App.objects.get(id=app_id)
            p.is_integration = True
            if user.is_superuser:
                p.approved = True
                if settings.DISCOURSE_TOKEN:
                    self._create_discourse_category(app_id)
            else:
                send_mail(
                    "New integration submitted", "Please review the "
                    "integration to make "
                    "sure it fits the "
                    "guidelines.", settings.NEXTCLOUD_FROM_EMAIL,
                    settings.NEXTCLOUD_INTEGRATIONS_APPROVAL_EMAILS)
            p.save()
            if self.data['screenshot']:
                screenshot = Screenshot.objects.create(
                    url=self.cleaned_data['screenshot'],
                    small_thumbnail=self.cleaned_data['screenshot_thumbnail'],
                    ordering=1,
                    app=p)
                screenshot.save()
            if not p.is_integration or p.approved or user.is_superuser:
                return app_id
class FormFieldsetForm(FormFieldsetMixIn, Form):
    single_choices = [
        ('A', 'Option A'),
        ('B', 'Option B'),
        ('C', 'Option C'),
    ]
    multi_choices = [
        ('A', 'Include A'),
        ('B', 'Include B'),
        ('C', 'Include C'),
    ]
    DEFAULT_CITY = 'Seattle'
    DEFAULT_COUNTRY_AREA_STATE = 'WA'
    # Already imported DEFAULT_COUNTRY

    first = CharField(initial='first_value')
    second = CharField(initial='second_value')
    first_name = CharField(initial='first_name')
    last_name = CharField(initial='last_name')
    generic_field = CharField(initial='original_value')
    billing_address_1 = CharField(
        label='street address (line 1)',
        max_length=191,
        required=False,
    )
    billing_address_2 = CharField(
        label='street address (continued)',
        max_length=191,
        required=False,
    )
    billing_city = CharField(
        label='city',
        max_length=191,
        initial=DEFAULT_CITY,
        required=False,
    )
    billing_country_area = CharField(
        label='state',
        max_length=2,
        initial=DEFAULT_COUNTRY_AREA_STATE,
        required=False,
    )
    billing_postcode = CharField(
        label='zipcode',
        max_length=10,
        required=False,
    )
    billing_country_code = CharField(
        label='country',
        initial=DEFAULT_COUNTRY,
        max_length=2,
        required=False,
    )
    large_comment = CharField(initial='initial large comment',
                              widget=Textarea(attrs={
                                  "rows": 10,
                                  "cols": 40
                              }))
    small_comment = CharField(widget=Textarea(attrs={"rows": 2, "cols": 10}))
    simple_comment = CharField(widget=Textarea())
    hide_field = CharField(widget=HiddenInput(), initial='hide_data')
    bool_field = BooleanField(required=False)  # single checkbox
    single_select = ChoiceField(
        choices=single_choices)  # default widget select
    multi_select = MultipleChoiceField(choices=multi_choices)  # SelectMultiple
    radio_select = ChoiceField(choices=single_choices, widget=RadioSelect)
    single_check = ChoiceField(choices=single_choices,
                               required=False,
                               widget=CheckboxInput)  # single/boolean choice
    multi_check = MultipleChoiceField(choices=multi_choices,
                                      widget=CheckboxSelectMultiple)
    email_test = EmailField(
    )  # like CharField, can have: max_length, min_length, and empty_value
    disable_field = CharField(disabled=True, initial='disable_data')
    another_field = CharField(initial='initial_data')
    last = CharField(initial='last_value')

    adjust_label_width = False
    called_prep_fields = False
    called_handle_modifiers = False
    called_assign_focus_field = False
    named_focus = None
    fields_focus = None
    hold_field = {}
    name_for_coded = 'generic_field'  # Used for testing if 'coded' fieldset fieldnames work as needed.

    def prep_fields(self):
        """This is a placeholder to mock when FormOverrideMixIn is combined with this FormFieldsetMixIn. """
        self.called_prep_fields = True
        return self.fields

    def handle_modifiers(self, opts, *args, **kwargs):
        """This is a placeholder to mock when FormOverrideMixIn is combined with this FormFieldsetMixIn. """
        self.called_handle_modifiers = True
        remove_name = kwargs.pop('remove_field', None)
        add_name = kwargs.pop('add_field', None)
        if remove_name:
            self.hold_field.update({remove_name: self.fields.pop(remove_name)})
        if add_name:
            if add_name not in self.hold_field:
                raise ValueError(
                    f"Unable to retrieve {add_name} from {self.hold_field}")
            found = {add_name: self.hold_field.pop(add_name)}
            field_rows, remaining_fields, *fs_args = args
            remaining_fields.update(found)
            self.fields.update(found)
            args = (field_rows, remaining_fields, *fs_args)
        return (opts, *args, kwargs)

    def assign_focus_field(self, name=None, fields=None):
        """This is a placeholder to mock when FocusMixIn is combined with this FormFieldsetMixIn. """
        self.called_assign_focus_field = True
        fields = fields or self.fields
        return name if name in fields else None
Beispiel #15
0
class IntegrationScaffoldingForm(Form):
    name = CharField(max_length=80,
                     label=_('Integration name'),
                     widget=TextInput())
    author_homepage = URLField(label=_('Author\'s homepage'), required=False)
    issue_tracker = URLField(label=_('Issue tracker URL'),
                             required=False,
                             help_text=_('Bug reports and feature requests'))
    categories = MultipleChoiceField(widget=HiddenInput(),
                                     disabled=True,
                                     required=True,
                                     label=_('Categories'),
                                     choices=lazy(get_categories, list),
                                     help_text=_('Hold down Ctrl and click to '
                                                 'select multiple entries'))
    summary = CharField(
        max_length=256,
        label=_('Summary'),
        help_text=
        _('Short description of your app that will be rendered as short teaser'
          ))
    screenshot = URLField(max_length=256,
                          label=_('Screenshot URL'),
                          required=False,
                          help_text=_('URL for integration screenshot'))
    screenshot_thumbnail = URLField(max_length=256,
                                    label=_('Screenshot '
                                            'thumbnail URL'),
                                    required=False,
                                    help_text=_('URL for integration '
                                                'screenshot in '
                                                'smaller dimensions. '
                                                'Must be used in combination '
                                                'with a larger screenshot.'))
    description = CharField(widget=Textarea,
                            label=_('Description'),
                            help_text=_('Full description of what your'
                                        ' integration '
                                        'does. Can contain Markdown.'))

    def save(self, user, app_id, action):
        if app_id is None:
            app_id = self.cleaned_data['name'].lower().replace(" ", "_")
        try:
            app = App.objects.get(id=app_id)
            if app.can_update(user) or user.is_superuser:
                if action == "reject" and user.is_superuser:
                    '''Not optimal but works'''
                    Screenshot.objects.filter(app=app).delete()
                    app.delete()
                elif action == "approve" and user.is_superuser:
                    app.approved = True
                    if settings.DISCOURSE_TOKEN:
                        self._create_discourse_category(app_id)
                    app.save()
                    return app_id
                else:
                    '''Not optimal but works'''
                    Screenshot.objects.filter(app=app).delete()
                    if self.data['screenshot']:
                        screenshot = Screenshot.objects.create(
                            url=self.cleaned_data['screenshot'],
                            small_thumbnail=self.
                            cleaned_data['screenshot_thumbnail'],
                            ordering=1,
                            app=app)
                        screenshot.save()

                    app.description = self.cleaned_data['description']
                    app.name = self.cleaned_data['name']
                    app.summary = self.cleaned_data['summary']
                    app.website = self.cleaned_data['author_homepage']
                    app.issue_tracker = self.cleaned_data['issue_tracker']
                    app.save()
                    return app_id
        except App.DoesNotExist:
            app = App.objects.create(id=app_id,
                                     owner=user,
                                     certificate=uuid.uuid1().urn)
            app.set_current_language('en')
            app.categories.set(self.cleaned_data['categories'])
            app.description = self.cleaned_data['description']
            app.name = self.cleaned_data['name']
            app.summary = self.cleaned_data['summary']
            app.website = self.cleaned_data['author_homepage']
            app.issue_tracker = self.cleaned_data['issue_tracker']
            app.save()
            p = App.objects.get(id=app_id)
            p.is_integration = True
            if user.is_superuser:
                p.approved = True
                if settings.DISCOURSE_TOKEN:
                    self._create_discourse_category(app_id)
            else:
                send_mail(
                    "New integration submitted", "Please review the "
                    "integration to make "
                    "sure it fits the "
                    "guidelines.", settings.NEXTCLOUD_FROM_EMAIL,
                    settings.NEXTCLOUD_INTEGRATIONS_APPROVAL_EMAILS)
            p.save()
            if self.data['screenshot']:
                screenshot = Screenshot.objects.create(
                    url=self.cleaned_data['screenshot'],
                    small_thumbnail=self.cleaned_data['screenshot_thumbnail'],
                    ordering=1,
                    app=p)
                screenshot.save()
            if not p.is_integration or p.approved or user.is_superuser:
                return app_id
Beispiel #16
0
    def _create_field(self):
        """
        :param cde: Common Data Element instance
        :return: A field object ( with widget possibly)
        We use a few conventions to find field class/widget class definitions.
        A check is made for any customised fields or widgets in the client app ( which
        must have name custom_fields.py.)
        The custom_fields module must contain functions with take a cde and return a field object.
        A custom field function must have name like

        custom_field_CDECODE23  ( assuming CDECODE23 is the code of the CDE)

        This function must return a field object.

        Then a check to look up any overrides based on code /datatype in this package is performed.

        Datatypes having their own field classes nust exist in the fields module
        class CustomFieldCDECod334
        class DatatypeFieldSomeDatatypeName

        The same applies to special widgets we create

        class CustomWidgetCDECode233
        class DatatypeEWidgetSomeDataTypeName

        Finally a Django field is returned based the DATATYPE_DICTIONARY
        ( if no field mapping is found a TextArea field is returned.)

        TODO Refactor this!

        """
        options = self._get_field_options()
        if self._is_dropdown():
            choices = self._get_permitted_value_choices()
            options['choices'] = choices
            options['initial'] = self.UNSET_CHOICE
            if self._has_other_please_specify():
                other_please_specify_index = [
                    "other" in pair[0].lower() for pair in choices
                ].index(True)
                other_please_specify_value = choices[
                    other_please_specify_index][0]
                if self.cde.widget_name:
                    try:
                        widget_class = getattr(widgets, self.cde.widget_name)
                        widget = widget_class(main_choices=choices,
                                              other_please_specify_value=
                                              other_please_specify_value,
                                              unset_value=self.UNSET_CHOICE)
                    except BaseException:
                        widget = widgets.OtherPleaseSpecifyWidget(
                            main_choices=choices,
                            other_please_specify_value=
                            other_please_specify_value,
                            unset_value=self.UNSET_CHOICE)
                else:
                    widget = widgets.OtherPleaseSpecifyWidget(
                        main_choices=choices,
                        other_please_specify_value=other_please_specify_value,
                        unset_value=self.UNSET_CHOICE)

                return fields.CharField(max_length=80,
                                        required=options.get(
                                            "required", False),
                                        help_text=_(self.cde.instructions),
                                        widget=widget,
                                        label=_(self.cde.name))
            else:
                if self.cde.widget_name:
                    widget = self._widget_search(self.cde.widget_name)
                else:
                    widget = None

                if self.cde.allow_multiple:
                    widget = widget or CheckboxSelectMultiple
                    if widget:
                        options['widget'] = widget

                    options['choices'] = [
                        choice_pair for choice_pair in options['choices']
                        if choice_pair[1] != '---'
                    ]
                    return MultipleChoiceField(**options)
                else:
                    if widget:
                        options['widget'] = widget
                        if "RadioSelect" in str(widget):
                            # get rid of the unset choice
                            options["choices"] = options['choices'][1:]

                    if self.cde.code in [
                            "CDEPatientNextOfKinState",
                            "CDEPatientNextOfKinCountry"
                    ]:
                        # These are dynamic now and alter their reange lists dynamically so have
                        # to switch off validation
                        from rdrf.forms.dynamic.fields import ChoiceFieldNoValidation
                        return ChoiceFieldNoValidation(**options)

                    if self.cde.code in ['State', 'Country']:
                        # because these are dynamic lookup fields the usual validation wasn't
                        # working
                        from rdrf.forms.dynamic.fields import ChoiceFieldNonBlankValidation
                        return ChoiceFieldNonBlankValidation(**options)

                    return django.forms.ChoiceField(**options)
        else:
            # Not a drop down
            widget = None

            if self._has_field_override():
                field = self._get_field_override()
            elif self._has_field_for_dataype():
                field = self._get_field_for_datatype()
            else:
                if self._is_complex():
                    return self.complex_field_factory.create(options)
                # File Field
                if self._get_datatype() == 'file':
                    return self._create_file_field(options)

                if self._is_calculated_field():
                    try:
                        parser = CalculatedFieldScriptCreator(
                            self.registry,
                            self.registry_form,
                            self.section,
                            self.cde,
                            injected_model=self.primary_model,
                            injected_model_id=self.primary_id)
                        script = parser.get_script()
                        from rdrf.forms.widgets.widgets import CalculatedFieldWidget
                        options['widget'] = CalculatedFieldWidget(script)
                        return django.forms.CharField(**options)

                    except CalculatedFieldScriptCreatorError as pe:
                        logger.error("Calculated Field %s Error: %s" %
                                     (self.cde, pe))

                field_or_tuple = self.DATATYPE_DICTIONARY.get(
                    self.cde.datatype.lower(), django.forms.CharField)

                if isinstance(field_or_tuple, tuple):
                    field = field_or_tuple[0]
                    extra_options = field_or_tuple[1]
                    options.update(extra_options)
                else:
                    field = field_or_tuple

            if self.cde.widget_name:
                try:
                    widget = self._widget_search(self.cde.widget_name)
                except Exception as ex:
                    logger.error("Error setting widget %s for cde %s: %s" %
                                 (self.cde.widget_name, self.cde, ex))
                    raise ex
                    widget = None
            else:
                if self.cde.datatype.lower() == 'date':
                    from django.forms.extras.widgets import SelectDateWidget
                    years = [yr for yr in range(1920, 2012, 1)]
                    widget = SelectDateWidget(years=years)

            if self._has_widget_override():
                widget = self._get_widget_override()

            elif self._has_widget_for_datatype():
                widget = self._get_widget_for_datatype()

            if widget:
                options['widget'] = widget

            return field(**options)
Beispiel #17
0
class AddAssetForm(Form):
    """新增资产Form表单"""

    device_type_id = fields.ChoiceField(
        choices=models.Asset.device_type_choices,
        widget=widgets.Select(
            attrs={}
        )

    )
    device_status_id = fields.ChoiceField(
        choices=models.Asset.device_status_choices,
        widget=widgets.Select

    )

    hostname = fields.CharField(
        error_messages={
            "required": "主机名不能为空",
        },
        widget=widgets.Input(
            attrs={"class": "form-control", "name": "hostname", "type": "text"})
    )

    cabinet_num = fields.CharField(
        required=False,
        widget=widgets.Input(
            attrs={"class": "form-control", "placeholder": "请输入机柜号,没有可为空", "name": "hostname", "type": "text"})
    )

    cabinet_order = fields.CharField(
        required=False,
        widget=widgets.Input(
            attrs={"class": "form-control", "placeholder": "请输入机柜中所在位置,没有可为空", "name": "hostname", "type": "text"})
    )

    idc_id = fields.ChoiceField(
        required=False,
        choices=[],
        widget=widgets.Select

    )

    business_unit_id = fields.ChoiceField(
        required=False,
        choices=[],
        widget=widgets.Select

    )

    tag = MultipleChoiceField(
        error_messages={
            "required": "标签不能为空",
        },
        choices=models.Tag.objects.all().values_list('id', 'name'),
        widget=widgets.CheckboxSelectMultiple
    )

    def __init__(self, *args, **kwargs):
        super(AddAssetForm, self).__init__(*args, **kwargs)

        values = models.IDC.objects.all().values_list('id', 'name', 'floor')
        idc_values = [['', '---------']]
        for i in values:
            idc_values.append([i[0], "%s-%s" % (i[1], i[2])])
        self.fields['idc_id'].choices = idc_values

        values = models.BusinessUnit.objects.values_list('id', 'name')
        business_unit_values = [['', '---------']]
        for i in values:
            business_unit_values.append([i[0], i[1]])
        self.fields['business_unit_id'].choices = business_unit_values
Beispiel #18
0
class TVChannelsForm(forms.Form):
    channels = MultipleChoiceField(required=False,
                                   widget=CheckboxSelectMultiple())
class PreSelectedModelSearchForm(FacetedModelSearchForm):
    possible_facets = MultipleChoiceField(widget=CheckboxSelectMultiple,
                                          choices=(),
                                          required=False)
    connection = ChoiceField(choices=(), required=False)

    def __init__(self, *args, **kwargs):
        """
        If we're in a recognised faceting engine, display and allow faceting.
        """
        super(PreSelectedModelSearchForm, self).__init__(*args, **kwargs)
        # provide support for discovering the version installed.
        self.version = self.guess_haystack_version()
        if self.should_allow_faceting():
            self.fields['possible_facets'].choices = self.configure_faceting()

        if self.has_multiple_connections():
            self.fields['connection'].choices = self.get_possible_connections()
            self.fields['connection'].initial = 'default'
        else:
            self.fields['connection'].widget = HiddenInput()

    def is_haystack1(self):
        return getattr(settings, 'HAYSTACK_SEARCH_ENGINE', None) is not None

    def is_haystack2(self):
        return getattr(settings, 'HAYSTACK_CONNECTIONS', None) is not None

    def guess_haystack_version(self):
        if self.is_haystack1():
            logger.debug("Guessed Haystack 1.2.x")
            return 1
        if self.is_haystack2():
            logger.debug("Guessed Haystack 2.x")
            return 2
        return None

    def has_multiple_connections(self):
        if self.version == 1:
            return False
        elif self.version == 2:
            engine_2x = getattr(settings, 'HAYSTACK_CONNECTIONS', {})
            return len(engine_2x) > 1

    def get_possible_connections(self):
        engine_2x = getattr(settings, 'HAYSTACK_CONNECTIONS', {})
        return ((force_text(x), force_text(x))
                for x in sorted(engine_2x.keys()))

    def configure_faceting(self):
        if self.version == 2:
            from haystack import connections
            facet_fields = connections['default'].get_unified_index(
            )._facet_fieldnames
            possible_facets = facet_fields.keys()
        elif self.version == 1:
            possible_facets = []
            for k, v in self.searchqueryset.site._field_mapping().items():
                if v['facet_fieldname'] is not None:
                    possible_facets.append(v['facet_fieldname'])
        return [(x, x) for x in possible_facets]

    def should_allow_faceting(self):
        if self.version == 1:
            engine_1x = getattr(settings, 'HAYSTACK_SEARCH_ENGINE', None)
            return engine_1x in ('solr', 'xapian')
        elif self.version == 2:
            engine_2x = getattr(settings, 'HAYSTACK_CONNECTIONS', {})
            try:
                engine_2xdefault = engine_2x['default']['ENGINE']
                ok_engines = (
                    'solr' in engine_2xdefault,
                    'xapian' in engine_2xdefault,
                    'elasticsearch' in engine_2xdefault,
                )
                return any(ok_engines)
            except KeyError as e:
                raise ImproperlyConfigured(
                    "I think you're on Haystack 2.x without "
                    "a `HAYSTACK_CONNECTIONS` dictionary")
        # I think this is unreachable, but for safety's sake we're going to
        # assume that if it got here, we can't know faceting is OK and working
        # so we'll disable the feature.
        return False

    def no_query_found(self):
        """
        When nothing is entered, show everything, because it's a better
        useful default for our usage.
        """
        return self.searchqueryset.all()

    def search(self):
        sqs = super(PreSelectedModelSearchForm, self).search()
        cleaned_data = getattr(self, 'cleaned_data', {})
        to_facet_on = cleaned_data.get('possible_facets', [])
        connection = cleaned_data.get('connection', '')
        if self.has_multiple_connections() and connection:
            sqs = sqs.using(connection)
        if len(to_facet_on) > 0:
            for field in to_facet_on:
                sqs = sqs.facet(field)
        return sqs
Beispiel #20
0
    def __init__(self, *args, space_id=None, request=None, geometry_editable=False, is_json=False, **kwargs):
        self.request = request
        super().__init__(*args, **kwargs)
        creating = not self.instance.pk

        if hasattr(self.instance, 'author_id'):
            if self.instance.author_id is None:
                self.instance.author = request.user

        if 'geometry' in self.fields:
            if not geometry_editable:
                # can't see this geometry in editor
                self.fields.pop('geometry')
            else:
                # hide geometry widget
                self.fields['geometry'].widget = HiddenInput()
                if not creating:
                    self.initial['geometry'] = json.dumps(mapping(self.instance.geometry), separators=(',', ':'))

        if self._meta.model.__name__ == 'Source' and self.request.user.is_superuser:
            Source = self.request.changeset.wrap_model('Source')

            sources = {s['name']: s for s in Source.objects.all().values('name', 'access_restriction_id',
                                                                         'left', 'bottom', 'right', 'top')}
            used_names = set(sources.keys())
            all_names = set(os.listdir(settings.SOURCES_ROOT))
            if not creating:
                used_names.remove(self.instance.name)
                all_names.add(self.instance.name)
            self.fields['name'].widget = Select(choices=tuple((s, s) for s in sorted(all_names-used_names)))

            if creating:
                for s in sources.values():
                    s['access_restriction'] = s['access_restriction_id']
                    del s['access_restriction_id']
                self.fields['copy_from'] = ChoiceField(
                    choices=tuple((('', '---------'), ))+tuple(
                        (json.dumps(sources[name], separators=(',', ':'), cls=DjangoJSONEncoder), name)
                        for name in sorted(used_names)
                    ),
                    required=False
                )

            self.fields['fixed_x'] = DecimalField(label='fixed x', required=False,
                                                  max_digits=7, decimal_places=3, initial=0)
            self.fields['fixed_y'] = DecimalField(label='fixed y', required=False,
                                                  max_digits=7, decimal_places=3, initial=0)
            self.fields['scale_x'] = DecimalField(label='scale x (m/px)', required=False,
                                                  max_digits=7, decimal_places=3, initial=1)
            self.fields['scale_y'] = DecimalField(label='scale y (m/px)', required=False,
                                                  max_digits=7, decimal_places=3, initial=1)
            self.fields['lock_aspect'] = BooleanField(label='lock aspect ratio', required=False, initial=True)
            self.fields['lock_scale'] = BooleanField(label='lock scale (for moving)', required=False, initial=True)

            self.fields.move_to_end('lock_scale', last=False)
            self.fields.move_to_end('lock_aspect', last=False)
            self.fields.move_to_end('scale_y', last=False)
            self.fields.move_to_end('scale_x', last=False)
            self.fields.move_to_end('fixed_y', last=False)
            self.fields.move_to_end('fixed_x', last=False)
            self.fields.move_to_end('access_restriction', last=False)
            if creating:
                self.fields.move_to_end('copy_from', last=False)
            self.fields.move_to_end('name', last=False)

        if self._meta.model.__name__ == 'AccessRestriction':
            AccessRestrictionGroup = self.request.changeset.wrap_model('AccessRestrictionGroup')

            self.fields['groups'].label_from_instance = lambda obj: obj.title
            self.fields['groups'].queryset = AccessRestrictionGroup.qs_for_request(self.request)

        elif 'groups' in self.fields:
            LocationGroupCategory = self.request.changeset.wrap_model('LocationGroupCategory')

            kwargs = {'allow_'+self._meta.model._meta.default_related_name: True}
            categories = LocationGroupCategory.objects.filter(**kwargs).prefetch_related('groups')
            if self.instance.pk:
                instance_groups = tuple(self.instance.groups.values_list('pk', flat=True))
            else:
                instance_groups = ()

            self.fields.pop('groups')

            for category in categories:
                choices = tuple((str(group.pk), group.title)
                                for group in sorted(category.groups.all(), key=self.sort_group))
                category_groups = set(group.pk for group in category.groups.all())
                initial = tuple(str(pk) for pk in instance_groups if pk in category_groups)
                if category.single:
                    name = 'group_'+category.name
                    initial = initial[0] if initial else ''
                    choices = (('', '---'), )+choices
                    field = ChoiceField(label=category.title, required=False, initial=initial, choices=choices,
                                        help_text=category.help_text)
                else:
                    name = 'groups_'+category.name
                    field = MultipleChoiceField(label=category.title_plural, required=False,
                                                initial=initial, choices=choices,
                                                help_text=category.help_text)
                self.fields[name] = field

            if 'label_settings' in self.fields:
                self.fields.move_to_end('label_settings')

            for field in tuple(self.fields.keys()):
                if field.startswith('label_override'):
                    self.fields.move_to_end(field)

        if 'category' in self.fields:
            self.fields['category'].label_from_instance = attrgetter('title')

        if 'label_settings' in self.fields:
            self.fields['label_settings'].label_from_instance = attrgetter('title')

        if 'access_restriction' in self.fields:
            AccessRestriction = self.request.changeset.wrap_model('AccessRestriction')

            self.fields['access_restriction'].label_from_instance = lambda obj: obj.title
            self.fields['access_restriction'].queryset = AccessRestriction.qs_for_request(self.request)

        if 'base_mapdata_accessible' in self.fields:
            if not request.user.is_superuser:
                self.fields['base_mapdata_accessible'].disabled = True

        if space_id and 'target_space' in self.fields:
            Space = self.request.changeset.wrap_model('Space')

            GraphNode = self.request.changeset.wrap_model('GraphNode')
            GraphEdge = self.request.changeset.wrap_model('GraphEdge')

            cache_key = 'editor:neighbor_spaces:%s:%s%d' % (
                self.request.changeset.raw_cache_key_by_changes,
                AccessPermission.cache_key_for_request(request, with_update=False),
                space_id
            )
            other_spaces = cache.get(cache_key, None)
            if other_spaces is None:
                AccessPermission.cache_key_for_request(request, with_update=False) + ':' + str(request.user.pk or 0)
                space_nodes = set(GraphNode.objects.filter(space_id=space_id).values_list('pk', flat=True))
                space_edges = GraphEdge.objects.filter(
                    Q(from_node_id__in=space_nodes) | Q(to_node_id__in=space_nodes)
                ).values_list('from_node_id', 'to_node_id')
                other_nodes = set(chain(*space_edges)) - space_nodes
                other_spaces = set(GraphNode.objects.filter(pk__in=other_nodes).values_list('space_id', flat=True))
                other_spaces.discard(space_id)
                cache.set(cache_key, other_spaces, 900)

            for space_field in ('origin_space', 'target_space'):
                other_space_id = getattr(self.instance, space_field+'_id', None)
                if other_space_id:
                    other_spaces.add(other_space_id)

            space_qs = Space.qs_for_request(self.request).filter(pk__in=other_spaces)

            for space_field in ('origin_space', 'target_space'):
                if space_field in self.fields:
                    self.fields[space_field].label_from_instance = lambda obj: obj.title
                    self.fields[space_field].queryset = space_qs

        self.redirect_slugs = None
        self.add_redirect_slugs = None
        self.remove_redirect_slugs = None
        if 'slug' in self.fields:
            self.redirect_slugs = sorted(self.instance.redirects.values_list('slug', flat=True))
            self.fields['redirect_slugs'] = CharField(label=_('Redirecting Slugs (comma separated)'), required=False,
                                                      initial=','.join(self.redirect_slugs))
            self.fields.move_to_end('redirect_slugs', last=False)
            self.fields.move_to_end('slug', last=False)

        if 'from_node' in self.fields:
            self.fields['from_node'].widget = HiddenInput()

        if 'to_node' in self.fields:
            self.fields['to_node'].widget = HiddenInput()

        if 'data' in self.fields and 'data' in self.initial:
            self.initial['data'] = json.dumps(self.initial['data'])

        self.is_json = is_json
        self.missing_fields = tuple((name, field) for name, field in self.fields.items()
                                    if name not in self.data and not field.required)
Beispiel #21
0
    def __init__(self, *args, **kwargs):
        # kwargs: {'initial': {}, 'prefix': None, 'instance': <User: Truus>, 'request': <WSGIRequest: GET '/users/7/'>}
        self.request = kwargs.pop(
            'request'
        )  # To get request.user. Do not use kwargs.pop('user', None) due to potential security hole
        super(UserEditForm, self).__init__(*args, **kwargs)

        self.request_user = self.request.user

        self.requestuser_company_id = 0
        if self.request_user.company:
            self.requestuser_company_id = self.request_user.company.id

        self.this_instance = kwargs.get('instance')

        # this one doesn't work - selected_username does not show in form PPR2019-07-29
        #kwargs.update({'selected_username': self.this_instance.username_sliced})

        self.selecteduser_company_id = 0
        if self.this_instance.company:
            self.selecteduser_company_id = self.this_instance.company.id

    # ======= field 'Company' ============
    # PR2018-11-03 lock filed Company.
        self.fields['company'].disabled = True

        # ======= field 'first_name' ============
        # field 'first_name' stores username_sliced without 000001,
        # field 'first_name' is not in use
        self.fields['first_name'].disabled = True

        # ======= field 'dep_list' ============
        # TODO: Show only departments of selected school / examyear
        #dep_choices = Department.dep_list_choices(country=self.request.user.country)
        #self.fields['dep_list_field'] = MultipleChoiceField(
        #    required=False,
        #    widget=SelectMultiple,
        #    choices=dep_choices,
        #    label=_('Departments'),
        #    help_text=_('Select the departments where this user has access to. '
        #                'Press the Ctrl button to select multiple departments.')
        #)

        # ======= field 'department_field' ============
        # get value of selected_user_department_id
        # TODO correct into departmentbase
        #self.selected_user_department_id = 0
        #if self.this_instance.department:
        #    self.selected_user_department_id = self.this_instance.department.id
        # give value to _choices
        # TODO: Show only departments of selected school / examyear
        #dep_choices = Department.dep_list_choices(
        #    country=self.request.user.country,
        ##    # init_list_str=self.this_instance.dep_list
        #    )
        #self.fields['department_field'] = ChoiceField(
        #    required=False,
        # choises must be tuple or list, dictionary gives error: 'int' object is not iterable
        #    choices=dep_choices,
        #    label=_('Department'),
        # PR2018-07-31 debug: use schooldefault.id instead of schooldefault.
        # This showed always first item in choices: initial=self.this_instance.schooldefault
        # TODO correct into departmentbase
        #    initial=self.selected_user_department_id
        #)

        # ======= field 'Permits' ============
        self.permits_tuple = self.this_instance.permits_tuple
        self.fields['permit_list'] = MultipleChoiceField(
            required=False,
            widget=SelectMultiple,
            # choises must be tuple or list, dictionary gives error: 'int' object is not iterable
            choices=self.request.user.permits_choices,
            label='Permissions',
            help_text=
            _('Select one or more permissions from the list. Press the Ctrl button to select multiple permissions.'
              ),
            initial=self.permits_tuple)

        # ======= field 'is_active' ============
        # PR2018-06-22, value in is_active is stored as str: '0'=False, '1'=True
        __initial_is_active = 0
        if self.this_instance.is_active is not None:
            __initial_is_active = int(self.this_instance.is_active)

        self.fields['field_is_active'] = ChoiceField(
            choices=c.IS_ACTIVE_CHOICES,
            label=_('Active'),
            initial=__initial_is_active)
Beispiel #22
0
 class SomeForm(Form):
     field = MultipleChoiceField(choices=[('one', 'One')])
Beispiel #23
0
class PluginUpdateForm(Form):
    jails = MultipleChoiceField(required=True)

    def __init__(self, *args, **kwargs):
        kwargs.pop('oid')
        super(PluginUpdateForm, self).__init__(*args, **kwargs)
Beispiel #24
0
 def __init__(self, *args, **kwargs):
     super().__init__(*args, **kwargs)
     self.fields['restricted_fields'] = MultipleChoiceField(
         choices=self.fields_choices)
     self.fields['layer'].queryset = Layer.vectors.all()
Beispiel #25
0
    def __init__(self, *args, **kwargs):
        self.cid = kwargs.pop('course_id')
        self.course_id = Course.objects.get_record_by_id(self.cid)
        super().__init__(*args, **kwargs)
        FORMS = (('aktywność', 'aktywność'), ('egzamin', 'egzamin'),
                 ('kartkówka', 'kartkówka'), ('kolokwium', 'kolokwium'),
                 ('lista zadań', 'lista zadań'))
        TYPES = (
            ('punkty', 'punkty'),
            ('ocena', 'ocena'),
            ('procenty', 'procenty'),
        )
        i = 1
        self.fields['ects'] = IntegerField(min_value=0, max_value=30)
        self.fields[
            'ects'].label = '{0:d}. Wpisz ile punktów ECTS ma kurs:'.format(i)
        i += 1
        self.fields['formy'] = MultipleChoiceField(
            widget=CheckboxSelectMultiple, choices=FORMS)
        self.fields[
            'formy'].label = '{0:d}. Wybierz formy uzyskania ocen cząstkowych na kursie:'.format(
                i)
        i += 1
        self.fields['form_type'] = ChoiceField(choices=TYPES, required=False)
        self.fields[
            'form_type'].label = '{0:d}. Zaznacz rodzaj oceniania na kursie:'.format(
                i)
        i += 1

        YN = (('Tak', 'Tak'), ('Nie', 'Nie'))
        self.fields['mod_plus'] = ChoiceField(choices=YN)
        self.fields[
            'mod_plus'].label = '{0:d}. Czy możliwe jest podwyższenie oceny?'.format(
                i)
        i += 1
        self.fields['mod_plus_w'] = FloatField(min_value=0, required=False)
        self.fields[
            'mod_plus_w'].label = 'Wpisz o ile ocena może zostać podwyższona:'

        self.fields['mod_minus'] = ChoiceField(choices=YN)
        self.fields[
            'mod_minus'].label = '{0:d}. Czy możliwe jest obniżenie oceny?'.format(
                i)
        i += 1
        self.fields['mod_minus_w'] = FloatField(min_value=0, required=False)
        self.fields[
            'mod_minus_w'].label = 'Wpisz o ile ocena może zostać obniżona:'

        self.fields['mod_type'] = ChoiceField(choices=TYPES, required=False)
        self.fields[
            'mod_type'].label = '{0:d}. Wybierz w jakim typie jest modyfikacja oceny:'.format(
                i)
        i += 1

        for key in self.fields:
            self.fields[key].error_messages[
                'required'] = "To pole jest wymagane."
            if 'invalid' in self.fields[key].error_messages:
                self.fields[key].error_messages[
                    'invalid'] = 'To nie jest poprawna wartość'
            if 'min_value' in self.fields[key].error_messages:
                self.fields[key].error_messages[
                    'min_value'] = 'To nie jest poprawna wartość'
            if 'max_value' in self.fields[key].error_messages:
                self.fields[key].error_messages[
                    'max_value'] = 'To nie jest poprawna wartość'
Beispiel #26
0
 def test_multiplechoicefield_1(self):
     f = MultipleChoiceField(choices=[('1', 'One'), ('2', 'Two')])
     with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
         f.clean('')
     with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
         f.clean(None)
     self.assertEqual(['1'], f.clean([1]))
     self.assertEqual(['1'], f.clean(['1']))
     self.assertEqual(['1', '2'], f.clean(['1', '2']))
     self.assertEqual(['1', '2'], f.clean([1, '2']))
     self.assertEqual(['1', '2'], f.clean((1, '2')))
     with self.assertRaisesMessage(ValidationError, "'Enter a list of values.'"):
         f.clean('hello')
     with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
         f.clean([])
     with self.assertRaisesMessage(ValidationError, "'This field is required.'"):
         f.clean(())
     msg = "'Select a valid choice. 3 is not one of the available choices.'"
     with self.assertRaisesMessage(ValidationError, msg):
         f.clean(['3'])
Beispiel #27
0
    def fill_edit(self):
        enum_form = {
            'ACTIV': 'aktywność',
            'EXAM': 'egzamin',
            'QUIZ': 'kartkówka',
            'TEST': 'kolokwium',
            'LIST': 'lista zadań'
        }
        enum_type = {'PKT': 'punkty', 'PERC': 'procenty', 'MARK': 'ocena'}
        FORMS = (('aktywność', 'aktywność'), ('egzamin', 'egzamin'),
                 ('kartkówka', 'kartkówka'), ('kolokwium', 'kolokwium'),
                 ('lista zadań', 'lista zadań'))
        TYPES = (
            ('punkty', 'punkty'),
            ('ocena', 'ocena'),
            ('procenty', 'procenty'),
        )
        YN = (('Tak', 'Tak'), ('Nie', 'Nie'))
        comp = Components.objects.get_records_by_course_id(self.course_id)
        ects = self.course_id.ECTS
        mod = Modyfication.objects.get_records_by_course_id(self.course_id)
        i = 1
        self.fields['ects'] = IntegerField(min_value=0,
                                           max_value=30,
                                           initial=ects)
        self.fields[
            'ects'].label = '{0:d}. Wpisz ile punktów ECTS ma kurs:'.format(i)
        i += 1
        init_comp = []
        for c in comp:
            init_comp.append(enum_form[c.form])
        self.fields['formy'] = MultipleChoiceField(
            widget=CheckboxSelectMultiple, choices=FORMS, initial=init_comp)
        self.fields[
            'formy'].label = '{0:d}. Wybierz formy uzyskania ocen cząstkowych na kursie:'.format(
                i)
        i += 1

        c = enum_type[comp[0].type]

        self.fields['form_type'] = ChoiceField(choices=TYPES,
                                               required=False,
                                               initial=c)
        self.fields[
            'form_type'].label = '{0:d}. Zaznacz rodzaj oceniania na kursie:'.format(
                i)
        i += 1

        self.fields['mod_plus'] = ChoiceField(choices=YN, initial='Nie')
        self.fields['mod_plus_w'] = FloatField(min_value=0, required=False)
        if mod:
            for m in mod:
                if m.mod == 'PLUS':
                    self.fields['mod_plus'] = ChoiceField(choices=YN,
                                                          initial='Tak')
                    self.fields['mod_plus_w'] = FloatField(min_value=0,
                                                           required=False,
                                                           initial=m.val)

        self.fields[
            'mod_plus'].label = '{0:d}. Czy możliwe jest podwyższenie oceny?'.format(
                i)
        i += 1
        self.fields[
            'mod_plus_w'].label = 'Wpisz o ile ocena może zostać podwyższona:'

        self.fields['mod_minus'] = ChoiceField(choices=YN, initial='Nie')
        self.fields['mod_minus_w'] = FloatField(min_value=0, required=False)
        self.fields['mod_type'] = ChoiceField(choices=TYPES, required=False)
        if mod:
            for m in mod:
                if m.mod == 'MINUS':
                    self.fields['mod_minus'] = ChoiceField(choices=YN,
                                                           initial='Tak')
                    t = enum_type[m.type]
                    self.fields['mod_minus_t'] = ChoiceField(choices=TYPES,
                                                             required=False,
                                                             initial=t)
                    self.fields['mod_type'] = ChoiceField(choices=TYPES,
                                                          required=False,
                                                          initial=m.val)
        self.fields[
            'mod_minus'].label = '{0:d}. Czy możliwe jest obniżenie oceny?'.format(
                i)
        i += 1
        self.fields[
            'mod_minus_w'].label = 'Wpisz o ile ocena może zostać obniżona:'
        self.fields[
            'mod_type'].label = '{0:d}. Wybierz w jakim typie jest modyfikacja oceny:'.format(
                i)
        i += 1
Beispiel #28
0
class SearchForm(Form):
    keyword = CharField(widget=BootstrapTextInput, max_length=100, initial="*")
    content_type = MultipleChoiceField(widget=BootstrapSelectMultiple,
                                       choices=PREDEFINED_CONTENT_TYPES,
                                       initial={'*': [1, 2]})
Beispiel #29
0
    def fill_edit(self):
        YN = (('Tak', 'Tak'), ('Nie', 'Nie'))

        COURSES = (
            ('ćwiczenia', 'ćwiczenia'),
            ('laboratorium', 'laboratorium'),
        )
        cg = CourseGroup.objects.get_records_by_course_id(self.course_id)
        group = False
        if cg.exists():
            group = True

        comp = Components.objects.get_records_by_course_id(self.course_id)
        ects = self.course_id.ECTS
        mod = Modyfication.objects.get_records_by_course_id(self.course_id)

        if group:
            self.fields['if_cg'] = ChoiceField(choices=YN, initial="Tak")
        else:
            self.fields['if_cg'] = ChoiceField(choices=YN, initial="Nie")

        self.fields['if_cg'].label = '1. Czy kurs jest częścią grupy kursów?'

        my_list = []
        weight_list = [("", ""), ("", ""), ("", "")]
        all_types = Course.objects.get_all_types_by_id(self.course_id.id)
        if all_types:
            for el in all_types:
                if group:
                    if el.type == "C":
                        my_list.append("ćwiczenia")
                        weight_list[0] = (el.coursegroup.weight,
                                          el.coursegroup.minimum)
                    if el.type == "L":
                        my_list.append("laboratorium")
                        weight_list[1] = (el.coursegroup.weight,
                                          el.coursegroup.minimum)
                    if el.type == "W":
                        weight_list[2] = (el.coursegroup.weight,
                                          el.coursegroup.minimum)

        self.fields['courses'] = MultipleChoiceField(
            widget=CheckboxSelectMultiple,
            choices=COURSES,
            required=False,
            initial=my_list)
        self.fields[
            'courses'].label = '2. Zaznacz formy, w których odbywają się zajęcia w ramach grupy kursów:'

        self.fields['weight_c'] = FloatField(min_value=0,
                                             max_value=1,
                                             required=False,
                                             initial=weight_list[0][0])
        self.fields[
            'weight_c'].label = '3. Wpisz udział oceny z ćwiczeń w ocenie końcowej z grupy kursów:'

        self.fields['weight_l'] = FloatField(min_value=0,
                                             max_value=1,
                                             required=False,
                                             initial=weight_list[1][0])
        self.fields[
            'weight_l'].label = '4. Wpisz udział oceny z laboratorium w ocenie końcowej z grupy kursów:'

        self.fields['weight_w'] = FloatField(min_value=0,
                                             max_value=1,
                                             required=False,
                                             initial=weight_list[2][0])
        self.fields[
            'weight_w'].label = '5. Wpisz udział oceny z wykładu w ocenie końcowej z grupy kursów:'

        if weight_list[0] != " " and weight_list[0][1]:
            self.fields['minimum'] = ChoiceField(choices=YN, initial="Tak")
        else:
            self.fields['minimum'] = ChoiceField(choices=YN, initial="Nie")
        self.fields[
            'minimum'].label = '6. Czy oceny z wszystkich kursów wchodzących w grupę muszą być większe niż 2?'
Beispiel #30
0
class OptionCheckbox(BaseOptionAnswer):
    answer = MultipleChoiceField(widget=CheckboxSelectMultiple)
 def test_disabled_has_changed(self):
     f = MultipleChoiceField(choices=[("1", "One"), ("2", "Two")],
                             disabled=True)
     self.assertIs(f.has_changed("x", "y"), False)