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)}
