class UserSelect(forms.Form): user = forms.CharField(label='User wählen:', widget=forms.RadioSelect( attrs={'onchange': 'changed(this);'}, choices=USER_CHOICES))
class DonateForm(forms.Form): RADIO_CHOICES = [] donation_type = forms.ChoiceField(widget=forms.RadioSelect(), choices=RADIO_CHOICES) name_option = forms.CharField(required=False, max_length=255) amount = forms.FloatField(initial=10.0, min_value=0.5) recurring = forms.BooleanField(required=False, initial=False, label='I want this to be a recurring monthly donation',) show_amount = forms.BooleanField( label='Make donated amount public', required=False, initial=True) def __init__(self, *args, **kwargs): user = kwargs.pop('user', None) default_donation_amount = kwargs.pop('default_donation_amount', None) super(DonateForm, self).__init__(*args, **kwargs) choices = [ ('1', "Anonymous"), ('2', "Other: "), ] self.user_id = None if user.username: self.user_id = user.id choices.insert(0, ('0', user.username)) self.initial['donation_type'] = '0' else: self.initial['donation_type'] = '1' self.fields['donation_type'].choices = choices if default_donation_amount is not None: self.initial['amount'] = float(default_donation_amount) def clean(self): cleaned_data = super(DonateForm, self).clean() amount = cleaned_data.get('amount') try: if not amount or float(amount) < 1: raise forms.ValidationError('The amount must be more than 1') except ValueError: raise forms.ValidationError('The amount must be a valid number, use \'.\' for decimals') campaign = DonationCampaign.objects.order_by('date_start').last() returned_data = { "campaign_id": campaign.id, "display_amount": cleaned_data.get('show_amount') } annon = cleaned_data.get('donation_type') # We store the user even if the donation is annonymous if self.user_id : returned_data['user_id'] = self.user_id if annon == '1': returned_data['name'] = "Anonymous" elif annon == '2': returned_data['name'] = cleaned_data.get('name_option', '') if returned_data['name'] == '': raise forms.ValidationError('You have to enter a name to display') # Paypal gives only one field to add extra data so we send it as b64 self.encoded_data = base64.b64encode(json.dumps(returned_data)) return cleaned_data
class ContributionForm(forms.ModelForm): contributor = forms.ModelChoiceField( queryset=UserProfile.objects.exclude_inactive_users()) responsibility = forms.ChoiceField( widget=forms.RadioSelect(), choices=Contribution.RESPONSIBILITY_CHOICES) course = forms.ModelChoiceField(Course.objects.all(), disabled=True, required=False, widget=forms.HiddenInput()) questionnaires = forms.ModelMultipleChoiceField( Questionnaire.objects.filter(is_for_contributors=True, obsolete=False), required=False, widget=CheckboxSelectMultiple, label=_("Questionnaires")) does_not_contribute = forms.BooleanField( required=False, label=_("Does not contribute to course")) class Meta: model = Contribution fields = ('course', 'contributor', 'questionnaires', 'order', 'responsibility', 'comment_visibility', 'label') widgets = { 'order': forms.HiddenInput(), 'comment_visibility': forms.RadioSelect(choices=Contribution.COMMENT_VISIBILITY_CHOICES) } field_classes = { 'contributor': UserModelChoiceField, } def __init__(self, *args, course=None, **kwargs): self.course = course # work around https://code.djangoproject.com/ticket/25880 if self.course is None: assert 'instance' in kwargs self.course = kwargs['instance'].course super().__init__(*args, **kwargs) self.fields['contributor'].widget.attrs['class'] = 'form-control' self.fields['label'].widget.attrs['class'] = 'form-control' if self.instance.responsible: self.fields['responsibility'].initial = Contribution.IS_RESPONSIBLE elif self.instance.can_edit: self.fields['responsibility'].initial = Contribution.IS_EDITOR else: self.fields['responsibility'].initial = Contribution.IS_CONTRIBUTOR self.fields['questionnaires'].queryset = Questionnaire.objects.filter( is_for_contributors=True).filter( Q(obsolete=False) | Q(contributions__course=self.course)).distinct() if self.instance.pk: self.fields[ 'does_not_contribute'].initial = not self.instance.questionnaires.exists( ) if not self.course.can_staff_edit: # form is used as read-only course view disable_all_fields(self) def clean(self): if not self.cleaned_data.get( 'does_not_contribute') and not self.cleaned_data.get( 'questionnaires'): self.add_error( 'does_not_contribute', _("Select either this option or at least one questionnaire!")) def save(self, *args, **kwargs): responsibility = self.cleaned_data['responsibility'] is_responsible = responsibility == Contribution.IS_RESPONSIBLE is_editor = responsibility == Contribution.IS_EDITOR self.instance.responsible = is_responsible self.instance.can_edit = is_responsible or is_editor if is_responsible: self.instance.comment_visibility = Contribution.ALL_COMMENTS return super().save(*args, **kwargs)
def get_Vars_form(obj_var): obj=obj_var #判断表单格式生成合适表单 var_name = obj.name content = {} if obj.value_form_type == "Select": new_fields = { var_name: forms.ChoiceField(label='变量名', error_messages={'required': '不能为空'},widget=forms.Select(attrs={'class': 'form-control'})) } elif obj.value_form_type == "RadioSelect": new_fields = { var_name: forms.ChoiceField(label='变量名', error_messages={'required': '不能为空'},widget=forms.RadioSelect(attrs={'class': 'list-group'})) } elif obj.value_form_type == "SelectMultiple": new_fields = { var_name: forms.MultipleChoiceField(label='变量名',error_messages={'required': '不能为空'},widget=forms.SelectMultiple(attrs={'class': 'form-control'})) } elif obj.value_form_type == "CheckboxSelectMultiple": new_fields = { var_name: forms.MultipleChoiceField(label='变量名',error_messages={'required': '不能为空'},widget=forms.CheckboxSelectMultiple(attrs={'class': 'list-group'})) } elif obj.value_form_type == "TextInput": new_fields = { var_name: forms.CharField(label='变量名', error_messages={'required': '不能为空'},widget=forms.TextInput(attrs={'class': 'form-control'})) } elif obj.value_form_type == "Textarea": new_fields = { var_name: forms.CharField(label='变量名', error_messages={'required': '不能为空'},widget=forms.Textarea(attrs={'class': 'form-control'})) } else: pass tpl_Custom_form = type('tpl_Custom_form', (Custom_form,), new_fields) tpl_Custom_form = tpl_Custom_form(initial=content) #判断变量来源获取变量内容 if obj.value_method == "admin_def": obj_value_optional = eval(obj.value_optional) tpl_Custom_form.fields[var_name].widget.choices = list_to_formlist(obj_value_optional) elif obj.value_method == "script": l1 = subprocess.getoutput(obj.value_script) obj_value_optional = eval(l1) tpl_Custom_form.fields[var_name].widget.choices = list_to_formlist(obj_value_optional) elif obj.value_method == "manual": pass tpl_Custom_form.fields[var_name].label = obj.label_name return tpl_Custom_form
class RegionForm(forms.Form): regions = forms.MultipleChoiceField( required=False, choices=[], widget=forms.CheckboxSelectMultiple, label=_lazy(u'Choose the regions your app will be listed in:'), error_messages={ 'required': _lazy(u'You must select at least one region.') }) enable_new_regions = forms.BooleanField(required=False, label=_lazy(u'Enable new regions')) restricted = forms.TypedChoiceField( required=False, initial=0, coerce=int, choices=[(0, _lazy('Make my app available in most regions')), (1, _lazy('Choose where my app is made available'))], widget=forms.RadioSelect(attrs={'class': 'choices'})) def __init__(self, *args, **kw): self.product = kw.pop('product', None) self.request = kw.pop('request', None) super(RegionForm, self).__init__(*args, **kw) self.fields['regions'].choices = REGIONS_CHOICES_SORTED_BY_NAME() # This is the list of the user's exclusions as we don't # want the user's choices to be altered by external # exclusions e.g. payments availability. user_exclusions = list( self.product.addonexcludedregion.values_list('region', flat=True)) # If we have excluded regions, uncheck those. # Otherwise, default to everything checked. self.regions_before = self.product.get_region_ids( restofworld=True, excluded=user_exclusions) self.initial = { 'regions': sorted(self.regions_before), 'restricted': int(self.product.geodata.restricted), 'enable_new_regions': self.product.enable_new_regions, } @property def regions_by_id(self): return mkt.regions.REGIONS_CHOICES_ID_DICT def is_toggling(self): if not self.request or not hasattr(self.request, 'POST'): return False return self.product.premium_type != mkt.ADDON_FREE def _product_is_paid(self): return (self.product.premium_type in mkt.ADDON_PREMIUMS or self.product.premium_type == mkt.ADDON_FREE_INAPP) def clean_regions(self): regions = self.cleaned_data['regions'] if not self.is_toggling(): if not regions: raise forms.ValidationError( _('You must select at least one region.')) return regions def save(self): # Don't save regions if we are toggling. if self.is_toggling(): return regions = [int(x) for x in self.cleaned_data['regions']] restricted = int(self.cleaned_data['restricted'] or 0) if restricted: before = set(self.regions_before) after = set(regions) log.info(u'[Webapp:%s] App marked as restricted.' % self.product) # Add new region exclusions. to_add = before - after for region in to_add: aer, created = self.product.addonexcludedregion.get_or_create( region=region) if created: log.info(u'[Webapp:%s] Excluded from new region (%s).' % (self.product, region)) # Remove old region exclusions. to_remove = after - before for region in to_remove: self.product.addonexcludedregion.filter(region=region).delete() log.info(u'[Webapp:%s] No longer excluded from region (%s).' % (self.product, region)) # If restricted, check how we should handle new regions. if self.cleaned_data['enable_new_regions']: self.product.update(enable_new_regions=True) log.info(u'[Webapp:%s] will be added to future regions.' % self.product) else: self.product.update(enable_new_regions=False) log.info(u'[Webapp:%s] will not be added to future regions.' % self.product) else: # If not restricted, set `enable_new_regions` to True and remove # currently excluded regions. self.product.update(enable_new_regions=True) self.product.addonexcludedregion.all().delete() log.info(u'[Webapp:%s] App marked as unrestricted.' % self.product) self.product.geodata.update(restricted=restricted)
class LicenseForm(AMOModelForm): builtin = forms.TypedChoiceField(choices=[], coerce=int, widget=forms.RadioSelect(attrs={'class': 'license'}, renderer=LicenseChoiceRadio)) name = forms.CharField(widget=TranslationTextInput(), label=_lazy(u"What is your license's name?"), required=False, initial=_('Custom License')) text = forms.CharField(widget=TranslationTextarea(), required=False, label=_lazy(u'Provide the text of your license.')) def __init__(self, *args, **kw): addon = kw.pop('addon', None) self.version = None if addon: qs = addon.versions.order_by('-version')[:1] self.version = qs[0] if qs else None if self.version: kw['instance'], kw['initial'] = self.version.license, None # Clear out initial data if it's a builtin license. if getattr(kw['instance'], 'builtin', None): kw['initial'] = {'builtin': kw['instance'].builtin} kw['instance'] = None super(LicenseForm, self).__init__(*args, **kw) cs = [(x.builtin, x) for x in License.objects.builtins().filter(on_form=True)] cs.append((License.OTHER, _('Other'))) self.fields['builtin'].choices = cs class Meta: model = License fields = ('builtin', 'name', 'text') def clean_name(self): name = self.cleaned_data['name'] return name.strip() or _('Custom License') def clean(self): data = self.cleaned_data if self.errors: return data elif data['builtin'] == License.OTHER and not data['text']: raise forms.ValidationError( _('License text is required when choosing Other.')) return data def get_context(self): """Returns a view context dict having keys license_urls, license_form, and license_other_val. """ license_urls = dict(License.objects.builtins() .values_list('builtin', 'url')) return dict(license_urls=license_urls, version=self.version, license_form=self.version and self, license_other_val=License.OTHER) def save(self, *args, **kw): """Save all form data. This will only create a new license if it's not one of the builtin ones. Keyword arguments **log=True** Set to False if you do not want to log this action for display on the developer dashboard. """ log = kw.pop('log', True) changed = self.changed_data builtin = self.cleaned_data['builtin'] if builtin != License.OTHER: license = License.objects.get(builtin=builtin) else: # Save the custom license: license = super(LicenseForm, self).save(*args, **kw) if self.version: if changed or license != self.version.license: self.version.update(license=license) if log: amo.log(amo.LOG.CHANGE_LICENSE, license, self.version.addon) return license
class CandidateRegistration(forms.ModelForm): name = forms.CharField(max_length=100, required=True) std_no_regex = RegexValidator(regex=r"^\d{7}$") std_no = forms.CharField(validators=[std_no_regex], max_length=7, required=False) email = forms.EmailField(required=True) father = forms.CharField(max_length=255, required=False) phone_regex = RegexValidator(regex=r"^[789]\d{9}$") phone_number = forms.CharField(validators=[phone_regex], max_length=10, required=False) branch = forms.ChoiceField(choices=BRANCH_CHOICES, required=False) skills = forms.CharField(max_length=255, required=False) designer = forms.CharField(max_length=255, required=False) year = forms.ChoiceField(choices=year_choices) hosteler = forms.ChoiceField(widget=forms.RadioSelect(), label='Are you a Hosteler?', choices=YES_OR_NO, required=False) captcha = ReCaptchaField(widget=ReCaptchaWidget()) class Meta: model = Candidate fields = [ 'name', 'email', 'std_no', 'phone_number', 'branch', 'year', 'hosteler', 'skills', 'designer', 'test_name', 'father', 'captcha', 'university_roll_no' ] def clean(self): cleaned_data = super(CandidateRegistration, self).clean() university_roll_no = None try: student_number = cleaned_data['std_no'] except KeyError: raise ValidationError("Student Number not valid!") try: university_roll_no = cleaned_data['university_roll_no'] except KeyError: raise ValidationError("University Roll Number not valid!") year = datetime.date.today().year end = '' start = '' for i in range(year, year - 5, -1): end += str(i % 10) i = int(i / 10) start += str(i % 10) regex_student = "^[" + start + "][" + end + "](12|14|10|13|00|31|21|32|40)[0-2][0-9][0-9][-]?[mdlMDL]?$" regex_university = "^[" + start + "][" + end + "][0][2][7](12|14|10|13|00|31|21|32|40)[0-9][0-9][0-9]$" pattern_student = re.compile(regex_student) pattern_university = re.compile(regex_university) if student_number: if not pattern_student.match(str(student_number)): raise ValidationError("Invalid Student Number") if university_roll_no: if not pattern_university.match(str(university_roll_no)) or ( len(university_roll_no) != 10): raise ValidationError("Invalid University Roll Number") return cleaned_data
class SystemImporterFileCsvFormbasedForm(forms.ModelForm, SystemImporterFileCsvConfigbasedForm): # reorder field choices systemstatus = forms.ModelChoiceField( queryset=Systemstatus.objects.order_by('systemstatus_name'), label='Systemstatus (*)', required=True, widget=forms.RadioSelect(), ) # reorder field choices analysisstatus = forms.ModelChoiceField( queryset=Analysisstatus.objects.order_by('analysisstatus_name'), label='Analysisstatus', required=False, widget=forms.RadioSelect(), ) # reorder field choices reason = forms.ModelChoiceField( label=gettext_lazy('Reason for investigation'), queryset=Reason.objects.order_by('reason_name'), required=False, widget=forms.RadioSelect(), ) domain = forms.ModelChoiceField( label=gettext_lazy('Domain'), queryset=Domain.objects.order_by('domain_name'), required=False, widget=forms.RadioSelect(), ) dnsname = forms.ModelChoiceField( label=gettext_lazy('DNS name'), queryset=Dnsname.objects.order_by('dnsname_name'), required=False, widget=forms.RadioSelect(), ) systemtype = forms.ModelChoiceField( label=gettext_lazy('Systemtype'), queryset=Systemtype.objects.order_by('systemtype_name'), required=False, widget=forms.RadioSelect(), ) os = forms.ModelChoiceField( label=gettext_lazy('Os'), queryset=Os.objects.order_by('os_name'), required=False, widget=forms.RadioSelect(), ) location = forms.ModelChoiceField( label=gettext_lazy('Location'), queryset=Location.objects.order_by('location_name'), required=False, widget=forms.RadioSelect(), ) serviceprovider = forms.ModelChoiceField( label=gettext_lazy('Serviceprovider'), queryset=Serviceprovider.objects.order_by('serviceprovider_name'), required=False, widget=forms.RadioSelect(), ) # case case = forms.ModelMultipleChoiceField( widget=forms.CheckboxSelectMultiple(), required=False, queryset=Case.objects.order_by('case_name'), label='Cases', ) # company company = forms.ModelMultipleChoiceField( widget=forms.CheckboxSelectMultiple(), required=False, queryset=Company.objects.order_by('company_name'), label='Companies', ) # tag tag = forms.ModelMultipleChoiceField( widget=forms.CheckboxSelectMultiple(), required=False, queryset=Tag.objects.order_by('tag_name'), label='Tags', ) class Meta: model = System # this HTML forms are shown fields = ( 'systemstatus', 'analysisstatus', 'reason', 'domain', 'dnsname', 'systemtype', 'os', 'location', 'serviceprovider', )
class RegionForm(forms.Form): regions = forms.MultipleChoiceField(required=False, label=_lazy(u'Choose the regions your app will be listed in:'), choices=mkt.regions.REGIONS_CHOICES_NAME, widget=forms.CheckboxSelectMultiple, error_messages={'required': _lazy(u'You must select at least one region.')}) special_regions = forms.MultipleChoiceField(required=False, choices=[(x.id, x.name) for x in mkt.regions.SPECIAL_REGIONS], widget=forms.CheckboxSelectMultiple) enable_new_regions = forms.BooleanField(required=False, label=_lazy(u'Enable new regions')) restricted = forms.TypedChoiceField(required=False, choices=[(0, _lazy('Make my app available in most regions')), (1, _lazy('Choose where my app is made available'))], widget=forms.RadioSelect(attrs={'class': 'choices'}), initial=0, coerce=int) def __init__(self, *args, **kw): self.product = kw.pop('product', None) self.request = kw.pop('request', None) super(RegionForm, self).__init__(*args, **kw) # If we have excluded regions, uncheck those. # Otherwise, default to everything checked. self.regions_before = self.product.get_region_ids(worldwide=True) self.initial = { 'regions': sorted(self.regions_before), 'restricted': int(self.product.geodata.restricted), 'enable_new_regions': self.product.enable_new_regions, } # The checkboxes for special regions are # # - checked ... if an app has not been requested for approval in # China or the app has been rejected in China. # # - unchecked ... if an app has been requested for approval in # China or the app has been approved in China. unchecked_statuses = (amo.STATUS_NULL, amo.STATUS_REJECTED) for region in self.special_region_objs: if self.product.geodata.get_status(region) in unchecked_statuses: # If it's rejected in this region, uncheck its checkbox. if region.id in self.initial['regions']: self.initial['regions'].remove(region.id) elif region.id not in self.initial['regions']: # If it's pending/public, check its checkbox. self.initial['regions'].append(region.id) self.disabled_regions = sorted(self._disabled_regions()) def _disabled_regions(self): disabled_regions = set() # Games cannot be listed in Brazil/Germany without a content rating. games = Webapp.category('games') if games and self.product.categories.filter(id=games.id).exists(): for region in mkt.regions.ALL_REGIONS_WITH_CONTENT_RATINGS: if not self.product.content_ratings_in(region): disabled_regions.add(region.id) return disabled_regions @property def regions_by_id(self): return mkt.regions.REGIONS_CHOICES_ID_DICT @property def special_region_objs(self): return mkt.regions.SPECIAL_REGIONS @property def special_region_ids(self): return mkt.regions.SPECIAL_REGION_IDS @property def special_region_statuses(self): """Returns the null/pending/public status for each region.""" statuses = {} for region in self.special_region_objs: statuses[region.id] = self.product.geodata.get_status_slug(region) return statuses @property def special_region_messages(self): """Returns the L10n messages for each region's status.""" return self.product.geodata.get_status_messages() def is_toggling(self): if not self.request or not hasattr(self.request, 'POST'): return False value = self.request.POST.get('toggle-paid') return value if value in ('free', 'paid') else False def _product_is_paid(self): return (self.product.premium_type in amo.ADDON_PREMIUMS or self.product.premium_type == amo.ADDON_FREE_INAPP) def clean_regions(self): regions = self.cleaned_data['regions'] if not self.is_toggling(): if not regions: raise forms.ValidationError( _('You must select at least one region.')) # Handle disabled regions. for region in regions: if region in self.disabled_regions: raise region_error(region) return regions def save(self): # Don't save regions if we are toggling. if self.is_toggling(): return regions = [int(x) for x in self.cleaned_data['regions']] special_regions = [ int(x) for x in self.cleaned_data['special_regions'] ] restricted = int(self.cleaned_data['restricted'] or 0) if restricted: before = set(self.regions_before) after = set(regions) log.info(u'[Webapp:%s] App mark as restricted.' % self.product) # Add new region exclusions. to_add = before - after for region in to_add - set(self.disabled_regions): aer, created = self.product.addonexcludedregion.get_or_create( region=region) if created: log.info(u'[Webapp:%s] Excluded from new region (%s).' % (self.product, region)) # Remove old region exclusions. to_remove = after - before for region in to_remove.union(self.disabled_regions): self.product.addonexcludedregion.filter( region=region).delete() log.info(u'[Webapp:%s] No longer exluded from region (%s).' % (self.product, region)) else: self.product.addonexcludedregion.all().delete() log.info(u'[Webapp:%s] App mark as unrestricted.' % self.product) self.product.geodata.update(restricted=restricted) # TODO: Stop saving AddonExcludedRegion objects when IARC work lands. toggle_game(self.product) # Toggle region exclusions/statuses for special regions (e.g., China). toggle_app_for_special_regions(self.request, self.product, special_regions) if self.cleaned_data['enable_new_regions']: self.product.update(enable_new_regions=True) log.info(u'[Webapp:%s] will be added to future regions.' % self.product) else: self.product.update(enable_new_regions=False) log.info(u'[Webapp:%s] will not be added to future regions.' % self.product)
def __init__(self, *args, **kwargs): """ Dynamically create fields using the membership application chosen. The choices provided to these dynamic fields are the csv import columns. """ step_numeral, step_name = kwargs.pop('step', (None, None)) corp_app = kwargs.pop('corp_app', '') file_path = kwargs.pop('file_path', '') super(CSVForm, self).__init__(*args, **kwargs) if step_numeral == 1: """ Basic Form: Application & File Uploader """ self.fields['corp_app'] = forms.ModelChoiceField( label=_('Corp Application'), queryset=CorpApp.objects.all()) self.fields['update_option'] = forms.CharField( widget=forms.RadioSelect( choices=(('skip', 'Skip'), ('update', 'Update Blank Fields'), ('override', 'Override All Fields'),)), initial='skip', label=_('Select an Option for the Existing Records:') ) self.fields['csv'] = forms.FileField(label=_("CSV File")) if step_numeral == 2: """ Basic Form + Mapping Fields """ # file to make field-mapping form csv = csv_to_dict(file_path) # choices list choices = csv[0].keys() # make tuples; sort tuples (case-insensitive) choice_tuples = [(c, c) for c in csv[0].keys()] # insert blank option choice_tuples.insert(0, ('', '')) choice_tuples = sorted(choice_tuples, key=lambda c: c[0].lower()) app_fields = CorpField.objects.filter(corp_app=corp_app) required_fields = ['name', 'corporate_membership_type'] for field in app_fields: if field.field_type not in ['section_break', 'page_break']: if field.field_name: field_key = field.field_name else: field_key = "field_%s" % field.id is_required = False if field_key in required_fields: is_required = True self.fields[field_key] = ChoiceField(**{ 'label': field.label, 'choices': choice_tuples, 'required': is_required, }) for choice in choices: if (field.label).lower() == choice.lower() or \ field_key.lower() == choice.lower(): self.fields[field_key].initial = choice extra_fields = (('secret_code', 'Secret Code'), ('join_dt', 'Join Date'), ('renew_dt', 'Renew Date'), ('expiration_dt', 'Expiration Date'), ('approved', 'Approved'), ('dues_rep', 'Dues Representative'), ('status', 'Status'), ('status_detail', 'Status Detail')) # corp_memb_field_names = [smart_str(field.name) # for field in CorporateMembership._meta.fields] for key, label in extra_fields: if key not in self.fields.keys(): self.fields[key] = ChoiceField(**{ 'label': label, 'choices': choice_tuples, 'required': False, }) for choice in choices: if label.lower() == choice.lower() or \ key.lower() == choice.lower(): self.fields[key].initial = choice
class ReviewForm(forms.Form): # Hack to restore behavior from pre Django 1.10 times. # Django 1.10 enabled `required` rendering for required widgets. That # wasn't the case before, this should be fixed properly but simplifies # the actual Django 1.11 deployment for now. # See https://github.com/mozilla/addons-server/issues/8912 for proper fix. use_required_attribute = False comments = forms.CharField(required=True, widget=forms.Textarea(), label=_(u'Comments:')) canned_response = NonValidatingChoiceField(required=False) action = forms.ChoiceField(required=True, widget=forms.RadioSelect()) versions = ModelMultipleChoiceField( widget=forms.SelectMultiple(attrs={'class': 'data-toggle'}), required=False, queryset=Version.objects.none()) # queryset is set later in __init__. operating_systems = forms.CharField(required=False, label=_(u'Operating systems:')) applications = forms.CharField(required=False, label=_(u'Applications:')) info_request = forms.BooleanField( required=False, label=_(u'Require developer to respond in less than…')) info_request_deadline = forms.IntegerField( required=False, widget=NumberInput, initial=7, label=_(u'days'), min_value=1, max_value=99) def is_valid(self): # Some actions do not require comments. action = self.helper.actions.get(self.data.get('action')) if action: if not action.get('comments', True): self.fields['comments'].required = False if action.get('versions', False): self.fields['versions'].required = True result = super(ReviewForm, self).is_valid() if result: self.helper.set_data(self.cleaned_data) return result def __init__(self, *args, **kw): self.helper = kw.pop('helper') super(ReviewForm, self).__init__(*args, **kw) # Info request deadline needs to be readonly unless we're an admin. user = self.helper.handler.user deadline_widget_attributes = {} info_request_deadline = self.fields['info_request_deadline'] if not acl.action_allowed_user(user, amo.permissions.REVIEWS_ADMIN): info_request_deadline.min_value = info_request_deadline.initial info_request_deadline.max_value = info_request_deadline.initial deadline_widget_attributes['readonly'] = 'readonly' deadline_widget_attributes.update({ 'min': info_request_deadline.min_value, 'max': info_request_deadline.max_value, }) info_request_deadline.widget.attrs.update(deadline_widget_attributes) # With the helper, we now have the add-on and can set queryset on the # versions field correctly. Small optimization: we only need to do this # if the relevant actions are available, otherwise we don't really care # about this field. versions_actions = [ k for k in self.helper.actions if self.helper.actions[k].get('versions') ] if versions_actions: if self.helper.version: channel = self.helper.version.channel else: channel = amo.RELEASE_CHANNEL_LISTED # For unlisted, we only care about approved versions, reviewers # aren't actively monitoring that queue. if channel == amo.RELEASE_CHANNEL_UNLISTED: statuses = (amo.STATUS_APPROVED, ) else: statuses = (amo.STATUS_APPROVED, amo.STATUS_AWAITING_REVIEW) self.fields['versions'].queryset = ( self.helper.addon.versions.distinct().filter( channel=channel, files__status__in=statuses). order_by('created')) # Reset data-value depending on widget depending on actions # available ([''] added to get an extra '|' at the end). self.fields['versions'].widget.attrs['data-value'] = '|'.join( versions_actions + [''] ) # For the canned responses, we're starting with an empty one, which # will be hidden via CSS. canned_choices = [ ['', [('', ugettext('Choose a canned response...'))]]] canned_type = ( amo.CANNED_RESPONSE_TYPE_THEME if self.helper.addon.type == amo.ADDON_STATICTHEME else amo.CANNED_RESPONSE_TYPE_ADDON) responses = CannedResponse.objects.filter(type=canned_type) # Loop through the actions (public, etc). for k, action in self.helper.actions.items(): action_choices = [[c.response, c.name] for c in responses if c.sort_group and k in c.sort_group.split(',')] # Add the group of responses to the canned_choices array. if action_choices: canned_choices.append([action['label'], action_choices]) # Now, add everything not in a group. for canned_response in responses: if not canned_response.sort_group: canned_choices.append( [canned_response.response, canned_response.name]) self.fields['canned_response'].choices = canned_choices # Set choices on the action field dynamically to raise an error when # someone tries to use an action they don't have access to. self.fields['action'].choices = [ (k, v['label']) for k, v in self.helper.actions.items()] @property def unreviewed_files(self): return (self.helper.version.unreviewed_files if self.helper.version else [])
class ReviewForm(forms.Form): # Hack to restore behavior from pre Django 1.10 times. # Django 1.10 enabled `required` rendering for required widgets. That # wasn't the case before, this should be fixed properly but simplifies # the actual Django 1.11 deployment for now. # See https://github.com/mozilla/addons-server/issues/8912 for proper fix. use_required_attribute = False comments = forms.CharField( required=True, widget=forms.Textarea(), label=_('Comments:') ) canned_response = NonValidatingChoiceField(required=False) action = forms.ChoiceField(required=True, widget=forms.RadioSelect()) versions = VersionsChoiceField( # The <select> is displayed/hidden dynamically depending on the action # so it needs the data-toggle class (data-value attribute is set later # during __init__). VersionsChoiceWidget takes care of adding that to # the individual <option> which is also needed for unlisted review # where for some actions we display the dropdown hiding some of the # versions it contains. widget=VersionsChoiceWidget(attrs={'class': 'data-toggle'}), required=False, queryset=Version.objects.none(), ) # queryset is set later in __init__. operating_systems = forms.CharField(required=False, label=_('Operating systems:')) applications = forms.CharField(required=False, label=_('Applications:')) delayed_rejection = forms.BooleanField( # For the moment we default to immediate rejections, but in the future # this will have to be dynamically set in __init__() to default to # delayed for listed review, and immediate for unlisted (the default # matters especially for unlisted where we don't intend to even show # the inputs, so we'll always use the initial value). # See https://github.com/mozilla/addons-server/pull/15025 initial=False, required=False, widget=forms.RadioSelect( choices=( ( True, _( 'Delay rejection, requiring developer to correct in ' 'less than…' ), ), ( False, _( 'Reject immediately. Only use in case of serious ' 'security issues.' ), ), ) ), ) delayed_rejection_days = forms.IntegerField( required=False, widget=NumberInput, initial=REVIEWER_DELAYED_REJECTION_PERIOD_DAYS_DEFAULT, label=_('days'), min_value=1, max_value=99, ) reasons = forms.ModelMultipleChoiceField( label=_('Choose one or more reasons:'), queryset=ReviewActionReason.objects.filter(is_active__exact=True), required=True, ) def is_valid(self): # Some actions do not require comments and reasons. action = self.helper.actions.get(self.data.get('action')) if action: if not action.get('comments', True): self.fields['comments'].required = False if action.get('versions', False): self.fields['versions'].required = True if not action.get('requires_reasons', False): self.fields['reasons'].required = False result = super().is_valid() if result: self.helper.set_data(self.cleaned_data) return result def __init__(self, *args, **kw): self.helper = kw.pop('helper') super().__init__(*args, **kw) # Delayed rejection period needs to be readonly unless we're an admin. user = self.helper.handler.user rejection_period_widget_attributes = {} rejection_period = self.fields['delayed_rejection_days'] if not acl.action_allowed_user(user, amo.permissions.REVIEWS_ADMIN): rejection_period.min_value = rejection_period.initial rejection_period.max_value = rejection_period.initial rejection_period_widget_attributes['readonly'] = 'readonly' rejection_period_widget_attributes['min'] = rejection_period.min_value rejection_period_widget_attributes['max'] = rejection_period.max_value rejection_period.widget.attrs.update(rejection_period_widget_attributes) # With the helper, we now have the add-on and can set queryset on the # versions field correctly. Small optimization: we only need to do this # if the relevant actions are available, otherwise we don't really care # about this field. versions_actions = [ k for k in self.helper.actions if self.helper.actions[k].get('versions') ] if versions_actions: if self.helper.version: channel = self.helper.version.channel else: channel = amo.RELEASE_CHANNEL_LISTED statuses = (amo.STATUS_APPROVED, amo.STATUS_AWAITING_REVIEW) self.fields['versions'].widget.versions_actions = versions_actions self.fields['versions'].queryset = ( self.helper.addon.versions(manager='unfiltered_for_relations') .filter(channel=channel, file__status__in=statuses) .no_transforms() .select_related('file') .order_by('created') ) # Reset data-value depending on widget depending on actions # available ([''] added to get an extra '|' at the end). self.fields['versions'].widget.attrs['data-value'] = '|'.join( versions_actions + [''] ) # For the canned responses, we're starting with an empty one, which # will be hidden via CSS. canned_choices = [['', [('', gettext('Choose a canned response...'))]]] canned_type = ( amo.CANNED_RESPONSE_TYPE_THEME if self.helper.addon.type == amo.ADDON_STATICTHEME else amo.CANNED_RESPONSE_TYPE_ADDON ) responses = CannedResponse.objects.filter(type=canned_type) # Loop through the actions (public, etc). for k, action in self.helper.actions.items(): action_choices = [ [c.response, c.name] for c in responses if c.sort_group and k in c.sort_group.split(',') ] # Add the group of responses to the canned_choices array. if action_choices: canned_choices.append([action['label'], action_choices]) # Now, add everything not in a group. for canned_response in responses: if not canned_response.sort_group: canned_choices.append([canned_response.response, canned_response.name]) self.fields['canned_response'].choices = canned_choices # Set choices on the action field dynamically to raise an error when # someone tries to use an action they don't have access to. self.fields['action'].choices = [ (k, v['label']) for k, v in self.helper.actions.items() ] @property def unreviewed_files(self): return ( (self.helper.version.file,) if self.helper.version and self.helper.version.file.status == amo.STATUS_AWAITING_REVIEW else () )
class ProfileForm(forms.ModelForm): CHOICES =(('1', "rainy"), ('2', "sunny")) city = forms.CharField(label="What city are you located in?", max_length=20) weather = forms.ChoiceField(choices=CHOICES, label="Which do you prefer:", widget=forms.RadioSelect(), initial=1) class Meta: model = Profile fields = ('city', 'weather')
class Meta: model = EmployeeMeal exclude = ['user', 'created_at', 'updated_at'] widgets = {'meal': forms.RadioSelect()}
def __init__(self, *args, **kwargs): super(ImpressoEnderecamentoForm, self).__init__(*args, **kwargs) self.fields['rotate'].widget = forms.RadioSelect() self.fields['rotate'].inline_class = True
def __init__(self, *args, **kwargs): user = kwargs.pop("user") account = kwargs.pop("account", None) self.user = user super(ReportForm, self).__init__(*args, **kwargs) # Three possible cases for `account` field: # a) account was given as a keyword argument, using a CharField, # rendered as a HiddenInput # b) account wasn't given explicitly and a user has an uber # permission, using a plain CharField # c) account wasn't given and a user is a simple user, using a # ModelChoiceField with all the user's real ib accounts if account: self.fields["account"] = forms.IntegerField( initial=account.mt4_id, widget=forms.HiddenInput, required=True) elif user.has_perm("reports.can_use_any_account"): self.fields["account"] = forms.IntegerField( label=_("Account"), help_text=_( "ID of the account you want to generate report for.")) else: self.fields["account"] = forms.ModelChoiceField( label=_("Account"), help_text=_("Select one of your accounts."), queryset=user.accounts.real_ib()) available_reports = [ (codename, report["type"] == reports.ACCOUNT_GROUP, report["type"] in (reports.GLOBAL, reports.PRIVATE_OFFICE)) for codename, report in settings.REPORTS.iteritems() if user.has_perm("reports.can_generate_%s" % codename) ] # если есть групповые отчеты среди доступных пользователю if any([ is_group_filter for name, is_group_filter, is_no_account in available_reports ]): qs = AccountGroup.objects.for_user(user) # если пользователь в группах не состоит, то пустые виджеты не выводим if qs: self.fields[ "account_group_include"] = forms.ModelMultipleChoiceField( label=_("Include"), help_text=mark_safe( string_concat( _("Include accounts from these groups. Empty means ALL accounts" ), _('. Click <a href="%s">here</a> to view group contents.' ) % reverse("reports_view_groups"))), queryset=qs, widget=forms.SelectMultiple(attrs={'size': 11}), required=not user.has_perm( "reports.can_use_any_account"), ) self.fields[ "account_group_exclude"] = forms.ModelMultipleChoiceField( label=_("Exclude"), help_text=_("Exclude accounts from these groups"), queryset=qs, widget=forms.SelectMultiple(attrs={'size': 11}), required=False, ) choices = [ (codename, settings.REPORTS[codename]["name"]) for codename, account_group_filter, no_account in available_reports # ---------------------------------------------- # account_group_filter | qs | show? # ---------------------------------------------- # True | [] | no # True | [..] | yes # False | [] | yes # False | [..] | yes if (not account_group_filter) or bool(qs) ] choices.sort(key=lambda i: i[1]) self.fields["report_type"] = forms.ChoiceField( label=_("Report type"), choices=choices, help_text=_("Choose one of the report types"), widget=forms.RadioSelect(), required=True) group_reports = [ codename for codename, is_group_report, no_account in available_reports if is_group_report ] no_account_reports = [ codename for codename, is_group_report, no_account in available_reports if no_account ] self.group_reports = mark_safe(json.dumps(group_reports)) self.no_account_reports = mark_safe(json.dumps(no_account_reports))
class Meta: model = Album exclude = ('album_author', 'album_date','album_privacy','album_comment') widgets = { 'album_privacy': forms.RadioSelect(attrs={'class': 'radio inline'}), }
class SimplePayShipForm(forms.Form): shipping = forms.ChoiceField(widget=forms.RadioSelect(), required=False) discount = forms.CharField(max_length=30, required=False) def __init__(self, request, paymentmodule, *args, **kwargs): super(SimplePayShipForm, self).__init__(*args, **kwargs) self.order = None self.orderpayment = None self.request = request try: self.tempCart = Cart.objects.from_request(request) if self.tempCart.numItems > 0: products = [ item.product for item in self.tempCart.cartitem_set.all() ] sale = find_best_auto_discount(products) if sale: self.fields["discount"].initial = sale.code except Cart.DoesNotExist: self.tempCart = None try: self.tempContact = Contact.objects.from_request(request) except Contact.DoesNotExist: self.tempContact = None if "default_view_tax" in kwargs: default_view_tax = kwargs["default_view_tax"] else: default_view_tax = config_value("TAX", "TAX_SHIPPING") shipping_choices, shipping_dict = _get_shipping_choices( request, paymentmodule, self.tempCart, self.tempContact, default_view_tax=default_view_tax, ) self.fields["shipping"].choices = shipping_choices self.shipping_dict = shipping_dict signals.payment_form_init.send(SimplePayShipForm, form=self) def clean_shipping(self): shipping = self.cleaned_data["shipping"] if not shipping and self.tempCart.is_shippable: raise forms.ValidationError(_("This field is required.")) return shipping def clean_discount(self): """ Check if discount exists and is valid. """ data = self.cleaned_data["discount"] if data: try: discount = Discount.objects.get(code=data, active=True) except Discount.DoesNotExist: raise forms.ValidationError(_("Invalid discount.")) valid, msg = discount.isValid(self.tempCart, self.request) if not valid: raise forms.ValidationError(msg) # TODO: validate that it can work with these products return data def save(self, request, cart, contact, payment_module): self.order = get_or_create_order(request, cart, contact, self.cleaned_data) self.orderpayment = create_pending_payment(self.order, payment_module) signals.form_save.send(SimplePayShipForm, form=self)
class PremiumForm(happyforms.Form): """ The premium details for an addon, which is unfortunately distributed across a few models. """ paypal_id = forms.CharField() price = forms.ModelChoiceField(queryset=Price.objects.active(), label=_lazy(u'Add-on price'), empty_label=None) do_upsell = forms.TypedChoiceField(coerce=lambda x: bool(int(x)), choices=UPSELL_CHOICES, widget=forms.RadioSelect(), required=False) free = forms.ModelChoiceField(queryset=Addon.objects.none(), required=False, empty_label='') support_email = forms.EmailField() def __init__(self, *args, **kw): self.extra = kw.pop('extra') self.request = kw.pop('request') self.addon = self.extra['addon'] kw['initial'] = { 'paypal_id': self.addon.paypal_id, 'support_email': self.addon.support_email, 'do_upsell': 0, } if self.addon.premium: kw['initial']['price'] = self.addon.premium.price upsell = self.addon.upsold if upsell: kw['initial'].update({ 'free': upsell.free, 'do_upsell': 1, }) super(PremiumForm, self).__init__(*args, **kw) if self.addon.is_webapp(): self.fields['price'].label = loc('App price') self.fields['do_upsell'].choices = APP_UPSELL_CHOICES self.fields['free'].queryset = (self.extra['amo_user'].addons .exclude(pk=self.addon.pk) .filter(premium_type=amo.ADDON_FREE, type=self.addon.type)) # For the wizard, we need to remove some fields. for field in self.extra.get('exclude', []): del self.fields[field] def _show_token_msg(self, message): """Display warning for an invalid PayPal refund token.""" url = paypal.get_permission_url(self.addon, self.extra.get('dest', 'payment'), ['REFUND']) msg = _(' <a href="%s">Visit PayPal to grant permission' ' for refunds on your behalf.</a>') % url messages.warning(self.request, '%s %s' % (message, Markup(msg))) raise forms.ValidationError(message) def clean_paypal_id(self): paypal_id = self.cleaned_data['paypal_id'] # Check it's a valid paypal id. check_paypal_id(paypal_id) if (self.addon.paypal_id and self.addon.paypal_id != paypal_id and self.addon.premium and self.addon.premium.has_permissions_token()): # If a user changes their paypal id, then we need # to nuke the token, but don't do this when it's is blank. self.addon.premium.paypal_permissions_token = '' self.addon.premium.save() return paypal_id def clean(self): paypal_id = self.cleaned_data.get('paypal_id', '') if paypal_id: # If we're going to prompt for refund permission, we need to # record the PayPal ID first. self.addon.paypal_id = paypal_id self.addon.save() # Check if third-party refund token is properly set up. no_token = (not self.addon.premium or not self.addon.premium.has_permissions_token()) invalid_token = (self.addon.premium and not self.addon.premium.has_valid_permissions_token()) if no_token or invalid_token: # L10n: We require PayPal users to have a third-party token set up. self._show_token_msg(loc('PayPal third-party refund token has not ' 'been set up or has recently expired.')) return self.cleaned_data def clean_free(self): if self.cleaned_data['do_upsell'] and not self.cleaned_data['free']: raise_required() return self.cleaned_data['free'] def save(self): if 'paypal_id' in self.cleaned_data: self.addon.paypal_id = self.cleaned_data['paypal_id'] self.addon.support_email = self.cleaned_data['support_email'] self.addon.save() if 'price' in self.cleaned_data: premium = self.addon.premium if not premium: premium = AddonPremium() premium.addon = self.addon premium.price = self.cleaned_data['price'] premium.save() upsell = self.addon.upsold if self.cleaned_data['do_upsell'] and self.cleaned_data['free']: # Check if this app was already a premium version for another app. if upsell and upsell.free != self.cleaned_data['free']: upsell.delete() if not upsell: upsell = AddonUpsell(premium=self.addon) upsell.free = self.cleaned_data['free'] upsell.save() elif not self.cleaned_data['do_upsell'] and upsell: upsell.delete()
class Meta: model = Student exclude = ['is_delete'] #排除前台不需要的字段 widgets = {'sex': forms.RadioSelect()}
class Meta: model = Contribution fields = ('evaluation', 'contributor', 'questionnaires', 'order', 'responsibility', 'textanswer_visibility', 'label') widgets = {'order': forms.HiddenInput(), 'textanswer_visibility': forms.RadioSelect(choices=Contribution.TEXTANSWER_VISIBILITY_CHOICES)}
class RespuestaForm(forms.Form): titulo = forms.ChoiceField(choices=TITULO_OPCIONES, widget=forms.RadioSelect())
class PublishForm(happyforms.Form): # Publish choice wording is slightly different here than with the # submission flow because the app may have already been published. mark_safe_lazy = lazy(mark_safe, six.text_type) PUBLISH_CHOICES = ( (mkt.PUBLISH_IMMEDIATE, mark_safe_lazy( _lazy( u'<b>Published</b>: Visible to everyone in the Marketplace and ' u'included in search results and listing pages.'))), (mkt.PUBLISH_HIDDEN, mark_safe_lazy( _lazy(u'<b>Unlisted</b>: Visible to only people with the URL and ' u'does not appear in search results and listing pages.'))), ) # Used for setting initial form values. PUBLISH_MAPPING = { mkt.STATUS_PUBLIC: mkt.PUBLISH_IMMEDIATE, mkt.STATUS_UNLISTED: mkt.PUBLISH_HIDDEN, mkt.STATUS_APPROVED: mkt.PUBLISH_PRIVATE, } # Use in form processing to set status. STATUS_MAPPING = dict((v, k) for k, v in PUBLISH_MAPPING.items()) publish_type = forms.TypedChoiceField(required=False, choices=PUBLISH_CHOICES, widget=forms.RadioSelect(), initial=0, coerce=int, label=_lazy('App Visibility:')) limited = forms.BooleanField( required=False, label=_lazy(u'<b>Limit to my team</b>: Visible to only Team Members.')) def __init__(self, *args, **kwargs): self.addon = kwargs.pop('addon') super(PublishForm, self).__init__(*args, **kwargs) limited = False publish = self.PUBLISH_MAPPING.get(self.addon.status, mkt.PUBLISH_IMMEDIATE) if self.addon.status == mkt.STATUS_APPROVED: # Special case if app is currently private. limited = True publish = mkt.PUBLISH_HIDDEN # Determine the current selection via STATUS to publish choice mapping. self.fields['publish_type'].initial = publish self.fields['limited'].initial = limited # Make the limited label safe so we can display the HTML. self.fields['limited'].label = mark_safe(self.fields['limited'].label) def save(self): publish = self.cleaned_data['publish_type'] limited = self.cleaned_data['limited'] if publish == mkt.PUBLISH_HIDDEN and limited: publish = mkt.PUBLISH_PRIVATE status = self.STATUS_MAPPING[publish] self.addon.update(status=status) mkt.log(mkt.LOG.CHANGE_STATUS, self.addon.get_status_display(), self.addon) # Call update_version, so various other bits of data update. self.addon.update_version() # Call to update names and locales if changed. self.addon.update_name_from_package_manifest() self.addon.update_supported_locales() if waffle.switch_is_active('iarc-upgrade-v2'): iarc_publish.delay(self.addon.pk) else: set_storefront_data.delay(self.addon.pk)
class StForm(forms.Form): station = forms.ModelChoiceField(queryset=AreaData.objects.all(), widget=forms.RadioSelect(), empty_label=None)
def __init__(self, alternatives, *args, **kwargs): super(AnswerForm, self).__init__(*args, **kwargs) self.fields['alternatives'] = forms.ChoiceField( choices=[(alternative.pk, alternative.text) for alternative in alternatives], widget=forms.RadioSelect())
class EditForm(forms.Form): def __init__(self, int_type_list, marca, index, *args, **kwargs): super(EditForm, self).__init__(*args, **kwargs) attrs = dict() if marca == "3": attrs["onChange"] = "javascript:setMask(" + str(index) + ")" attrs["style"] = "width: 98px;" self.fields['combo'].widget = forms.Select(attrs=attrs) self.fields['combo'].choices = [("", "Selecione"), ("Eth", "Eth"), ("Fa", "Fa"), ("Gi", "Gi"), ("mgmt", "mgmt"), ("Serial", "Serial"), ("Te", "Te")] elif marca == "21": attrs["onChange"] = "javascript:setMask(" + str(index) + ")" attrs["style"] = "width: 98px;" self.fields['combo'].widget = forms.Select(attrs=attrs) self.fields['combo'].choices = [("", "Selecione"), ("GE", "GE"), ("10GE", "10GE"), ("40GE", "40GE"), ("100GE", "100GE"), ("meth", "meth")] elif marca == "8": attrs["onChange"] = "javascript:setMask(" + str(index) + ")" attrs["style"] = "width: 98px;" self.fields['combo'].widget = forms.Select(attrs=attrs) self.fields['combo'].choices = [("", "Selecione"), ("For", "For"), ("Ten", "Ten"), ("Twe", "Twe")] else: attrs["style"] = "display: none;" self.fields['combo'].widget = forms.Select(attrs=attrs) self.fields['combo'].choices = [("", "")] widget = forms.TextInput(attrs={ "style": "width: 100px;", "readonly": True }) self.fields['name'].widget = widget combo = forms.ChoiceField(label="", required=False, error_messages=error_messages) name = forms.CharField(label="Nome da Interface", required=True, error_messages=error_messages, min_length=1, max_length=30) protected = forms.ChoiceField( label="Protegido", required=True, choices=[(0, "Não"), (1, "Sim")], error_messages=error_messages, widget=forms.RadioSelect(attrs={'disabled': 'disabled'}), initial=0) equip_name = forms.CharField(widget=forms.HiddenInput(), label='', required=False) equip_id = forms.IntegerField(widget=forms.HiddenInput(), label='', required=False) inter_id = forms.IntegerField(widget=forms.HiddenInput(), label='', required=False) front = forms.IntegerField(widget=forms.HiddenInput(), label='', required=False) back = forms.IntegerField(widget=forms.HiddenInput(), label='', required=False) channel = forms.CharField(widget=forms.HiddenInput(), label='', required=False) type = forms.CharField(widget=forms.HiddenInput(), label='', required=False)
class Meta: model = Endereco fields = '__all__' widgets = {'pessoa': forms.RadioSelect()}
class UserForm(forms.Form): # Widget - Charfield #username = forms.CharField(label='Username', max_length=100, initial='Enter user name') username = forms.CharField( widget=forms.TextInput(attrs={ 'placeholder': 'Username', 'class': 'djangoform' }), required=True, max_length="8") # Widget - Password # password = forms.CharField(widget=forms.PasswordInput()) password = forms.CharField(widget=forms.PasswordInput( attrs={ 'placeholder': 'Password', 'class': 'djangoform' })) # Widget - Email # email = forms.EmailField(label='Email', initial='We need your email') # email = forms.EmailField(widget=forms.TextInput(attrs={'placeholder': 'Email'}), required = True) email = forms.EmailField(widget=forms.EmailInput(attrs={ 'placeholder': 'Email', 'class': 'djangoform' }), required=True) # Widget - Integer Field - Same used for Phone number # contact = forms.IntegerField(widget=forms.NumberInput(attrs={'placeholder': 'Phone number', 'min':10}), required = True ) contact = forms.IntegerField( widget=forms.NumberInput(attrs={ 'placeholder': 'Phone number', 'class': 'djangoform' }), required=True) # upload Multiple files #upload_image = forms.FileField(widget=forms.ClearableFileInput(attrs={'multiple': True,'class': 'fileupload'}), required=False) upload_image = forms.ImageField( widget=forms.ClearableFileInput(attrs={ 'multiple': True, 'class': 'fileupload' }), required=False) #upload_image = forms.FileField(widget=forms.ClearableFileInput(attrs={'class': 'fileupload'}), required=False) # Date and Time Widgets # date = forms.DateField(widget=forms.SelectDateWidget) # date = forms.DateTimeField(widget = forms.SelectDateWidget()) # date = forms.DateTimeField(widget = DatePickerInput(format='%m/%d/%Y')) # date = forms.DateField(widget=DatePicker(options={"format": "mm/dd/yyyy", "autoclose": True })) # date = forms.DateField(widget=widgets.AdminDateWidget) # date = forms.DateField(widget= forms.DateInput(format='%d/%m/%Y')) # # Using AdminDate and Time widget ## date = forms.DateField( widget=widgets.AdminDateWidget(attrs={'placeholder': 'Date'}), required=False) #time = forms.DateField(widget=widgets.AdminTimeWidget(attrs={'placeholder': 'Time'}), required=False) time = forms.TimeField( widget=widgets.AdminTimeWidget(attrs={'placeholder': 'Time'}), required=False) # SelectDateWidget: BIRTH_YEAR_CHOICES = ['1980', '1981', '1982'] birth_year = forms.DateField(widget=forms.SelectDateWidget( years=BIRTH_YEAR_CHOICES)) # Widget Multiple Chocies FAVORITE_COLORS_CHOICES = [ ('blue', 'Blue'), ('green', 'Green'), ('black', 'Black'), ] favorite_color = forms.MultipleChoiceField(widget=forms.SelectMultiple(), required=False, choices=FAVORITE_COLORS_CHOICES) favorite_colors = forms.MultipleChoiceField( widget=forms.CheckboxSelectMultiple, required=False, choices=FAVORITE_COLORS_CHOICES) # Widget - Radio Chocies Widget CHOICES = [('1', 'First'), ('2', 'Second')] choice_field = forms.ChoiceField(widget=forms.RadioSelect(), choices=CHOICES, required=False) # Widget - url url = forms.URLField( widget=forms.URLInput(attrs={'Placeholder': 'Enter url'}), required=False) # Widget - Charfield and Text Field description = forms.CharField( widget=forms.TextInput(attrs={ 'Placeholder': 'Short description', 'size': '40' }), required=False) comments = forms.CharField(widget=forms.Textarea(attrs={ 'Placeholder': "Enter Comment", 'rows': 5 }), required=False) # Widget - Boolen yes_no = forms.BooleanField( label="Are you coming?, Click check box if coming.", required=False) boolean_null = forms.BooleanField(required=False, widget=forms.NullBooleanSelect()) yes_no = forms.BooleanField( label="Are you coming?, Click check box if coming.", required=False) On_Off = forms.BooleanField( widget=forms.CheckboxInput(attrs={ 'input type': 'checkbox', 'checked data-toggle': 'toggle' }), required=False) Enabled_Disabled = forms.BooleanField( label="Enabled/Disabled", required=False, widget=forms.CheckboxInput(attrs={ 'data-on': 'Enabled', 'data-off': 'Disabled', 'data-toggle': 'toggle' })) agree = forms.BooleanField(required=True) #yes_no = forms.BooleanField(widget=forms.CheckboxInput(), label="Are you coming?", required=False) # Widget - MultiWidget fields = ( forms.CharField(widget=forms.TextInput(attrs={'class': 'big'})), forms.CharField(widget=forms.TextInput(attrs={'class': 'big'})), forms.CharField(widget=forms.TextInput(attrs={'class': 'big'})), ) widge = [fields[0].widget, fields[1].widget, fields[2].widget]
class Meta: model = DisciplineCaseBase fields = ("response", ) widgets = { 'response': forms.RadioSelect(), }
class Meta: model = models.Menu fields = ['name', 'weight', 'icon'] widgets = {'icon': forms.RadioSelect(choices=ICON_CHOICE)}