addons-server/apps/devhub/forms.py

1139 строки
43 KiB
Python

# -*- coding: utf-8 -*-
import os
import re
import socket
from jinja2 import Markup
from django import forms
from django.conf import settings
from django.db.models import Q
from django.forms.models import modelformset_factory
from django.forms.formsets import formset_factory, BaseFormSet
from django.utils.safestring import mark_safe
from django.utils.encoding import force_unicode
from django.contrib import messages
import commonware
import happyforms
from tower import ugettext as _, ugettext_lazy as _lazy
from quieter_formset.formset import BaseModelFormSet
import waffle
import amo
import addons.forms
import paypal
from addons.models import (Addon, AddonDependency, AddonUpsell, AddonUser,
BlacklistedSlug, Charity, Preview)
from amo.helpers import loc
from amo.forms import AMOModelForm
from amo.urlresolvers import reverse
from amo.utils import raise_required, slugify
from applications.models import Application, AppVersion
from files.models import File, FileUpload, Platform
from files.utils import parse_addon, VERSION_RE
from market.models import AddonPremium, Price
from translations.widgets import TranslationTextarea, TranslationTextInput
from translations.fields import TransTextarea, TransField
from translations.models import delete_translation, Translation
from translations.forms import TranslationFormMixin
from versions.models import License, Version, ApplicationsVersions
from mkt.webapps.models import Webapp
from . import tasks
paypal_log = commonware.log.getLogger('z.paypal')
class AuthorForm(happyforms.ModelForm):
# TODO: Remove this whole __init__ when the 'allow-refund' flag goes away.
def __init__(self, *args, **kwargs):
super(AuthorForm, self).__init__(*args, **kwargs)
self.fields['role'].choices = (
(c, s) for c, s in amo.AUTHOR_CHOICES
if c != amo.AUTHOR_ROLE_SUPPORT or
waffle.switch_is_active('allow-refund'))
class Meta:
model = AddonUser
exclude = ('addon')
class BaseModelFormSet(BaseModelFormSet):
"""
Override the parent's is_valid to prevent deleting all forms.
"""
def is_valid(self):
# clean() won't get called in is_valid() if all the rows are getting
# deleted. We can't allow deleting everything.
rv = super(BaseModelFormSet, self).is_valid()
return rv and not any(self.errors) and not bool(self.non_form_errors())
class BaseAuthorFormSet(BaseModelFormSet):
def clean(self):
if any(self.errors):
return
# cleaned_data could be None if it's the empty extra form.
data = filter(None, [f.cleaned_data for f in self.forms
if not f.cleaned_data.get('DELETE', False)])
if not any(d['role'] == amo.AUTHOR_ROLE_OWNER for d in data):
raise forms.ValidationError(_('Must have at least one owner.'))
if not any(d['listed'] for d in data):
raise forms.ValidationError(
_('At least one author must be listed.'))
users = [d['user'] for d in data]
if sorted(users) != sorted(set(users)):
raise forms.ValidationError(
_('An author can only be listed once.'))
AuthorFormSet = modelformset_factory(AddonUser, formset=BaseAuthorFormSet,
form=AuthorForm, can_delete=True, extra=0)
class DeleteForm(happyforms.Form):
password = forms.CharField()
def __init__(self, request):
self.user = request.amo_user
super(DeleteForm, self).__init__(request.POST)
def clean_password(self):
data = self.cleaned_data
if not self.user.check_password(data['password']):
raise forms.ValidationError(_('Password incorrect.'))
class LicenseChoiceRadio(forms.widgets.RadioFieldRenderer):
def __iter__(self):
for i, choice in enumerate(self.choices):
yield LicenseRadioInput(self.name, self.value, self.attrs.copy(),
choice, i)
class LicenseRadioInput(forms.widgets.RadioInput):
def __init__(self, name, value, attrs, choice, index):
super(LicenseRadioInput, self).__init__(name, value, attrs, choice,
index)
license = choice[1] # Choice is a tuple (object.id, object).
link = u'<a class="xx extra" href="%s" target="_blank">%s</a>'
if hasattr(license, 'url'):
details = link % (license.url, _('Details'))
self.choice_label = mark_safe(self.choice_label + details)
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 PolicyForm(TranslationFormMixin, AMOModelForm):
"""Form for editing the add-ons EULA and privacy policy."""
has_eula = forms.BooleanField(required=False,
label=_lazy(u'This add-on has an End User License Agreement'))
eula = TransField(widget=TransTextarea(), required=False,
label=_lazy(u"Please specify your add-on's "
"End User License Agreement:"))
has_priv = forms.BooleanField(
required=False, label=_lazy(u"This add-on has a Privacy Policy"))
privacy_policy = TransField(widget=TransTextarea(), required=False,
label=_lazy(u"Please specify your add-on's Privacy Policy:"))
def __init__(self, *args, **kw):
self.addon = kw.pop('addon', None)
if not self.addon:
raise ValueError('addon keyword arg cannot be None')
kw['instance'] = self.addon
kw['initial'] = dict(has_priv=self._has_field('privacy_policy'),
has_eula=self._has_field('eula'))
super(PolicyForm, self).__init__(*args, **kw)
def _has_field(self, name):
# If there's a eula in any language, this addon has a eula.
n = getattr(self.addon, u'%s_id' % name)
return any(map(bool, Translation.objects.filter(id=n)))
class Meta:
model = Addon
fields = ('eula', 'privacy_policy')
def save(self, commit=True):
ob = super(PolicyForm, self).save(commit)
for k, field in (('has_eula', 'eula'),
('has_priv', 'privacy_policy')):
if not self.cleaned_data[k]:
delete_translation(self.instance, field)
if 'privacy_policy' in self.changed_data:
amo.log(amo.LOG.CHANGE_POLICY, self.addon, self.instance)
return ob
def ProfileForm(*args, **kw):
# If the add-on takes contributions, then both fields are required.
addon = kw['instance']
fields_required = (kw.pop('required', False) or
bool(addon.takes_contributions))
if addon.is_webapp():
the_reason_label = _('Why did you make this app?')
the_future_label = _("What's next for this app?")
else:
the_reason_label = _('Why did you make this add-on?')
the_future_label = _("What's next for this add-on?")
class _Form(TranslationFormMixin, happyforms.ModelForm):
the_reason = TransField(widget=TransTextarea(),
required=fields_required,
label=the_reason_label)
the_future = TransField(widget=TransTextarea(),
required=fields_required,
label=the_future_label)
class Meta:
model = Addon
fields = ('the_reason', 'the_future')
return _Form(*args, **kw)
class CharityForm(happyforms.ModelForm):
url = Charity._meta.get_field('url').formfield(verify_exists=False)
class Meta:
model = Charity
fields = ('name', 'url', 'paypal')
def clean_paypal(self):
check_paypal_id(self.cleaned_data['paypal'])
return self.cleaned_data['paypal']
def save(self, commit=True):
# We link to the charity row in contrib stats, so we force all charity
# changes to create a new row so we don't forget old charities.
if self.changed_data and self.instance.id:
self.instance.id = None
return super(CharityForm, self).save(commit)
class ContribForm(TranslationFormMixin, happyforms.ModelForm):
RECIPIENTS = (('dev', _lazy(u'The developers of this add-on')),
('moz', _lazy(u'The Mozilla Foundation')),
('org', _lazy(u'An organization of my choice')))
recipient = forms.ChoiceField(choices=RECIPIENTS,
widget=forms.RadioSelect(attrs={'class': 'recipient'}))
thankyou_note = TransField(widget=TransTextarea(), required=False)
class Meta:
model = Addon
fields = ('paypal_id', 'suggested_amount', 'annoying',
'enable_thankyou', 'thankyou_note')
widgets = {
'annoying': forms.RadioSelect(),
'suggested_amount': forms.TextInput(attrs={'class': 'short'}),
'paypal_id': forms.TextInput(attrs={'size': '50'})
}
@staticmethod
def initial(addon):
if addon.charity:
recip = 'moz' if addon.charity_id == amo.FOUNDATION_ORG else 'org'
else:
recip = 'dev'
return {'recipient': recip,
'annoying': addon.annoying or amo.CONTRIB_PASSIVE}
def clean(self):
if self.instance.upsell:
raise forms.ValidationError(_('You cannot setup Contributions for '
'an add-on that is linked to a premium '
'add-on in the Marketplace.'))
data = self.cleaned_data
try:
if not self.errors and data['recipient'] == 'dev':
check_paypal_id(data['paypal_id'])
except forms.ValidationError, e:
self.errors['paypal_id'] = self.error_class(e.messages)
# thankyou_note is a dict since it's a Translation.
if not (data.get('enable_thankyou') and
any(data.get('thankyou_note').values())):
data['thankyou_note'] = {}
data['enable_thankyou'] = False
return data
def clean_suggested_amount(self):
amount = self.cleaned_data['suggested_amount']
if amount is not None and amount <= 0:
msg = _(u'Please enter a suggested amount greater than 0.')
raise forms.ValidationError(msg)
if amount > settings.MAX_CONTRIBUTION:
msg = _(u'Please enter a suggested amount less than ${0}.').format(
settings.MAX_CONTRIBUTION)
raise forms.ValidationError(msg)
return amount
def check_paypal_id(paypal_id):
if not paypal_id:
raise forms.ValidationError(
_('PayPal ID required to accept contributions.'))
try:
valid, msg = paypal.check_paypal_id(paypal_id)
if not valid:
raise forms.ValidationError(msg)
except socket.error:
raise forms.ValidationError(_('Could not validate PayPal id.'))
class VersionForm(happyforms.ModelForm):
releasenotes = TransField(
widget=TransTextarea(), required=False)
approvalnotes = forms.CharField(
widget=TranslationTextarea(attrs={'rows': 4}), required=False)
class Meta:
model = Version
fields = ('releasenotes', 'approvalnotes')
class ApplicationChoiceField(forms.ModelChoiceField):
def label_from_instance(self, obj):
return obj.id
class AppVersionChoiceField(forms.ModelChoiceField):
def label_from_instance(self, obj):
return obj.version
class CompatForm(happyforms.ModelForm):
application = ApplicationChoiceField(Application.objects.all(),
widget=forms.HiddenInput)
min = AppVersionChoiceField(AppVersion.objects.none())
max = AppVersionChoiceField(AppVersion.objects.none())
class Meta:
model = ApplicationsVersions
fields = ('application', 'min', 'max')
def __init__(self, *args, **kw):
super(CompatForm, self).__init__(*args, **kw)
if self.initial:
app = self.initial['application']
else:
app = self.data[self.add_prefix('application')]
self.app = amo.APPS_ALL[int(app)]
qs = AppVersion.objects.filter(application=app).order_by('version_int')
self.fields['min'].queryset = qs.filter(~Q(version__contains='*'))
self.fields['max'].queryset = qs.all()
def clean(self):
min = self.cleaned_data.get('min')
max = self.cleaned_data.get('max')
if not (min and max and min.version_int <= max.version_int):
raise forms.ValidationError(_('Invalid version range.'))
return self.cleaned_data
class BaseCompatFormSet(BaseModelFormSet):
def __init__(self, *args, **kw):
super(BaseCompatFormSet, self).__init__(*args, **kw)
# We always want a form for each app, so force extras for apps
# the add-on does not already have.
qs = kw['queryset'].values_list('application', flat=True)
apps = [a for a in amo.APP_USAGE if a.id not in qs]
self.initial = ([{} for _ in qs] +
[{'application': a.id} for a in apps])
self.extra = len(amo.APP_GUIDS) - len(self.forms)
self._construct_forms()
def clean(self):
if any(self.errors):
return
apps = filter(None, [f.cleaned_data for f in self.forms
if not f.cleaned_data.get('DELETE', False)])
if not apps:
raise forms.ValidationError(
_('Need at least one compatible application.'))
CompatFormSet = modelformset_factory(
ApplicationsVersions, formset=BaseCompatFormSet,
form=CompatForm, can_delete=True, extra=0)
def verify_app_domain(manifest_url):
if waffle.switch_is_active('webapps-unique-by-domain'):
domain = Webapp.domain_from_url(manifest_url)
if Addon.objects.filter(app_domain=domain).exists():
raise forms.ValidationError(
_('An app already exists on this domain, '
'only one app per domain is allowed.'))
class NewWebappForm(happyforms.Form):
upload = forms.ModelChoiceField(widget=forms.HiddenInput,
queryset=FileUpload.objects.filter(valid=True),
error_messages={'invalid_choice': _lazy(u'There was an error with your'
' upload. Please try again.')})
def clean_upload(self):
upload = self.cleaned_data['upload']
verify_app_domain(upload.name) # JS puts manifest URL here
return upload
class NewAddonForm(happyforms.Form):
upload = forms.ModelChoiceField(widget=forms.HiddenInput,
queryset=FileUpload.objects.filter(valid=True),
error_messages={'invalid_choice': _lazy(u'There was an error with your'
' upload. Please try again.')})
desktop_platforms = forms.ModelMultipleChoiceField(
queryset=Platform.objects,
widget=forms.CheckboxSelectMultiple(attrs={'class': 'platform'}),
initial=[amo.PLATFORM_ALL.id],
required=False)
desktop_platforms.choices = ((p.id, p.name)
for p in amo.DESKTOP_PLATFORMS.values())
mobile_platforms = forms.ModelMultipleChoiceField(
queryset=Platform.objects,
widget=forms.CheckboxSelectMultiple(attrs={'class': 'platform'}),
required=False)
mobile_platforms.choices = ((p.id, p.name)
for p in amo.MOBILE_PLATFORMS.values())
def clean(self):
if not self.errors:
xpi = parse_addon(self.cleaned_data['upload'])
addons.forms.clean_name(xpi['name'])
self._clean_all_platforms()
return self.cleaned_data
def _clean_all_platforms(self):
if (not self.cleaned_data['desktop_platforms']
and not self.cleaned_data['mobile_platforms']):
raise forms.ValidationError(_('Need at least one platform.'))
class NewVersionForm(NewAddonForm):
def __init__(self, *args, **kw):
self.addon = kw.pop('addon')
super(NewVersionForm, self).__init__(*args, **kw)
def clean(self):
if not self.errors:
xpi = parse_addon(self.cleaned_data['upload'], self.addon)
if self.addon.versions.filter(version=xpi['version']):
raise forms.ValidationError(
_(u'Version %s already exists') % xpi['version'])
self._clean_all_platforms()
return self.cleaned_data
class NewFileForm(happyforms.Form):
upload = forms.ModelChoiceField(widget=forms.HiddenInput,
queryset=FileUpload.objects.filter(valid=True),
error_messages={'invalid_choice': _lazy(u'There was an error with your'
' upload. Please try again.')})
platform = File._meta.get_field('platform').formfield(empty_label=None,
widget=forms.RadioSelect(attrs={'class': 'platform'}))
platform.choices = sorted((p.id, p.name)
for p in amo.SUPPORTED_PLATFORMS.values())
def __init__(self, *args, **kw):
self.addon = kw.pop('addon')
self.version = kw.pop('version')
super(NewFileForm, self).__init__(*args, **kw)
# Reset platform choices to just those compatible with target app.
field = self.fields['platform']
field.choices = sorted((k, v.name) for k, v in
self.version.compatible_platforms().items())
# Don't allow platforms we already have.
to_exclude = set(File.objects.filter(version=self.version)
.values_list('platform', flat=True))
# Don't allow platform=ALL if we already have platform files.
if len(to_exclude):
to_exclude.add(amo.PLATFORM_ALL.id)
# Always exclude PLATFORM_ALL_MOBILE because it's not supported for
# downloads yet. The developer can choose Android + Maemo for now.
# TODO(Kumar) Allow this option when it's supported everywhere.
# See bug 646268.
to_exclude.add(amo.PLATFORM_ALL_MOBILE.id)
field.choices = [p for p in field.choices if p[0] not in to_exclude]
field.queryset = Platform.objects.filter(id__in=dict(field.choices))
def clean(self):
if not self.version.is_allowed_upload():
raise forms.ValidationError(
_('You cannot upload any more files for this version.'))
# Check for errors in the xpi.
if not self.errors:
xpi = parse_addon(self.cleaned_data['upload'], self.addon)
if xpi['version'] != self.version.version:
raise forms.ValidationError(_("Version doesn't match"))
return self.cleaned_data
class FileForm(happyforms.ModelForm):
platform = File._meta.get_field('platform').formfield(empty_label=None)
class Meta:
model = File
fields = ('platform',)
def __init__(self, *args, **kw):
super(FileForm, self).__init__(*args, **kw)
if kw['instance'].version.addon.type in (amo.ADDON_SEARCH,
amo.ADDON_WEBAPP):
del self.fields['platform']
else:
compat = kw['instance'].version.compatible_platforms()
# TODO(Kumar) Allow PLATFORM_ALL_MOBILE when it's supported.
# See bug 646268.
if amo.PLATFORM_ALL_MOBILE.id in compat:
del compat[amo.PLATFORM_ALL_MOBILE.id]
pid = int(kw['instance'].platform_id)
plats = [(p.id, p.name) for p in compat.values()]
if pid not in compat:
plats.append([pid, amo.PLATFORMS[pid].name])
self.fields['platform'].choices = plats
def clean_DELETE(self):
if any(self.errors):
return
delete = self.cleaned_data['DELETE']
if (delete and not self.instance.version.is_all_unreviewed):
error = _('You cannot delete a file once the review process has '
'started. You must delete the whole version.')
raise forms.ValidationError(error)
return delete
class BaseFileFormSet(BaseModelFormSet):
def clean(self):
if any(self.errors):
return
files = [f.cleaned_data for f in self.forms
if not f.cleaned_data.get('DELETE', False)]
if self.forms and 'platform' in self.forms[0].fields:
platforms = [f['platform'].id for f in files]
if amo.PLATFORM_ALL.id in platforms and len(files) > 1:
raise forms.ValidationError(
_('The platform All cannot be combined '
'with specific platforms.'))
if sorted(platforms) != sorted(set(platforms)):
raise forms.ValidationError(
_('A platform can only be chosen once.'))
FileFormSet = modelformset_factory(File, formset=BaseFileFormSet,
form=FileForm, can_delete=True, extra=0)
class ReviewTypeForm(forms.Form):
_choices = [(k, amo.STATUS_CHOICES[k]) for k in
(amo.STATUS_UNREVIEWED, amo.STATUS_NOMINATED)]
review_type = forms.TypedChoiceField(
choices=_choices, widget=forms.HiddenInput,
coerce=int, empty_value=None,
error_messages={'required': _lazy(u'A review type must be selected.')})
class Step3Form(addons.forms.AddonFormBasic):
description = TransField(widget=TransTextarea, required=False)
class Meta:
model = Addon
fields = ('name', 'slug', 'summary', 'tags', 'description',
'homepage', 'support_email', 'support_url')
class Step3WebappForm(Step3Form):
"""Form to override certain fields for webapps"""
name = TransField(max_length=128)
homepage = TransField.adapt(forms.URLField)(required=False,
verify_exists=False)
support_url = TransField.adapt(forms.URLField)(required=False,
verify_exists=False)
support_email = TransField.adapt(forms.EmailField)(required=False)
class PreviewForm(happyforms.ModelForm):
caption = TransField(widget=TransTextarea, required=False)
file_upload = forms.FileField(required=False)
upload_hash = forms.CharField(required=False)
def save(self, addon, commit=True):
if self.cleaned_data:
self.instance.addon = addon
if self.cleaned_data.get('DELETE'):
# Existing preview.
if self.instance.id:
self.instance.delete()
# User has no desire to save this preview.
return
super(PreviewForm, self).save(commit=commit)
if self.cleaned_data['upload_hash']:
upload_hash = self.cleaned_data['upload_hash']
upload_path = os.path.join(settings.TMP_PATH, 'preview',
upload_hash)
tasks.resize_preview.delay(upload_path, self.instance,
set_modified_on=[self.instance])
class Meta:
model = Preview
fields = ('caption', 'file_upload', 'upload_hash', 'id', 'position')
class BasePreviewFormSet(BaseModelFormSet):
def clean(self):
if any(self.errors):
return
PreviewFormSet = modelformset_factory(Preview, formset=BasePreviewFormSet,
form=PreviewForm, can_delete=True,
extra=1)
class AdminForm(happyforms.ModelForm):
type = forms.ChoiceField(choices=amo.ADDON_TYPE.items())
# Request is needed in other ajax forms so we're stuck here.
def __init__(self, request=None, *args, **kw):
super(AdminForm, self).__init__(*args, **kw)
class Meta:
model = Addon
fields = ('trusted', 'type', 'guid',
'target_locale', 'locale_disambiguation')
widgets = {
'guid': forms.TextInput(attrs={'size': '50'})
}
class InlineRadioRenderer(forms.widgets.RadioFieldRenderer):
def render(self):
return mark_safe(''.join(force_unicode(w) for w in self))
class PackagerBasicForm(forms.Form):
name = forms.CharField(min_length=5, max_length=50,
help_text=_lazy(u'Give your add-on a name. The most successful '
'add-ons give some indication of their function in '
'their name.'))
description = forms.CharField(required=False, widget=forms.Textarea,
help_text=_lazy(u'Briefly describe your add-on in one sentence. '
'This appears in the Add-ons Manager.'))
version = forms.CharField(max_length=32,
help_text=_lazy(u'Enter your initial version number. Depending on the '
'number of releases and your preferences, this is '
'usually 0.1 or 1.0'))
id = forms.CharField(
help_text=_lazy(u'Each add-on requires a unique ID in the form of a '
'UUID or an email address, such as '
'addon-name@developer.com. The email address does not '
'have to be valid.'))
package_name = forms.CharField(min_length=5, max_length=50,
help_text=_lazy(u'The package name of your add-on used within the '
'browser. This should be a short form of its name '
'(for example, Test Extension might be '
'test_extension).'))
author_name = forms.CharField(
help_text=_lazy(u'Enter the name of the person or entity to be '
'listed as the author of this add-on.'))
contributors = forms.CharField(required=False, widget=forms.Textarea,
help_text=_lazy(u'Enter the names of any other contributors to this '
'extension, one per line.'))
def clean_name(self):
name = self.cleaned_data['name']
addons.forms.clean_name(name)
name_regex = re.compile('(mozilla|firefox|thunderbird)', re.I)
if name_regex.match(name):
raise forms.ValidationError(
_('Add-on names should not contain Mozilla trademarks.'))
return name
def clean_package_name(self):
slug = self.cleaned_data['package_name']
if slugify(slug, ok='_', lower=False, delimiter='_') != slug:
raise forms.ValidationError(
_('Enter a valid package name consisting of letters, numbers, '
'or underscores.'))
if Addon.objects.filter(slug=slug).exists():
raise forms.ValidationError(
_('This package name is already in use.'))
if BlacklistedSlug.blocked(slug):
raise forms.ValidationError(
_(u'The package name cannot be: %s.' % slug))
return slug
def clean_id(self):
id_regex = re.compile(
"""(\{[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}\} | # GUID
[a-z0-9-\.\+_]*\@[a-z0-9-\._]+) # Email format""",
re.I | re.X)
if not id_regex.match(self.cleaned_data['id']):
raise forms.ValidationError(
_('The add-on ID must be a UUID string or an email '
'address.'))
return self.cleaned_data['id']
def clean_version(self):
if not VERSION_RE.match(self.cleaned_data['version']):
raise forms.ValidationError(_('The version string is invalid.'))
return self.cleaned_data['version']
class PackagerCompatForm(forms.Form):
enabled = forms.BooleanField(required=False)
min_ver = forms.ModelChoiceField(AppVersion.objects.none(),
empty_label=None, required=False,
label=_lazy(u'Minimum'))
max_ver = forms.ModelChoiceField(AppVersion.objects.none(),
empty_label=None, required=False,
label=_lazy(u'Maximum'))
def __init__(self, *args, **kwargs):
super(PackagerCompatForm, self).__init__(*args, **kwargs)
if not self.initial:
return
self.app = self.initial['application']
qs = (AppVersion.objects.filter(application=self.app.id)
.order_by('-version_int'))
self.fields['enabled'].label = self.app.pretty
if self.app == amo.FIREFOX:
self.fields['enabled'].widget.attrs['checked'] = True
# Don't allow version ranges as the minimum version.
self.fields['min_ver'].queryset = qs.filter(~Q(version__contains='*'))
self.fields['max_ver'].queryset = qs.all()
# Unreasonably hardcode a reasonable default minVersion.
if self.app in (amo.FIREFOX, amo.MOBILE, amo.THUNDERBIRD):
try:
self.fields['min_ver'].initial = qs.filter(
version=settings.DEFAULT_MINVER)[0]
except (IndexError, AttributeError):
pass
def clean_min_ver(self):
if self.cleaned_data['enabled'] and not self.cleaned_data['min_ver']:
raise_required()
return self.cleaned_data['min_ver']
def clean_max_ver(self):
if self.cleaned_data['enabled'] and not self.cleaned_data['max_ver']:
raise_required()
return self.cleaned_data['max_ver']
def clean(self):
if self.errors:
return
data = self.cleaned_data
if data['enabled']:
min_ver = data['min_ver']
max_ver = data['max_ver']
if not (min_ver and max_ver):
raise forms.ValidationError(_('Invalid version range.'))
if min_ver.version_int > max_ver.version_int:
raise forms.ValidationError(
_('Min version must be less than Max version.'))
# Pass back the app name and GUID.
data['min_ver'] = str(min_ver)
data['max_ver'] = str(max_ver)
data['name'] = self.app.pretty
data['guid'] = self.app.guid
return data
class PackagerCompatBaseFormSet(BaseFormSet):
def __init__(self, *args, **kw):
super(PackagerCompatBaseFormSet, self).__init__(*args, **kw)
self.initial = [{'application': a} for a in amo.APP_USAGE]
self._construct_forms()
def clean(self):
if any(self.errors):
return
if (not self.forms or not
any(f.cleaned_data.get('enabled') for f in self.forms
if f.app == amo.FIREFOX)):
# L10n: {0} is Firefox.
raise forms.ValidationError(
_(u'{0} is a required target application.')
.format(amo.FIREFOX.pretty))
return self.cleaned_data
PackagerCompatFormSet = formset_factory(PackagerCompatForm,
formset=PackagerCompatBaseFormSet, extra=0)
class PackagerFeaturesForm(forms.Form):
about_dialog = forms.BooleanField(
required=False,
label=_lazy(u'About dialog'),
help_text=_lazy(u'Creates a standard About dialog for your '
'extension'))
preferences_dialog = forms.BooleanField(
required=False,
label=_lazy(u'Preferences dialog'),
help_text=_lazy(u'Creates an example Preferences window'))
toolbar = forms.BooleanField(
required=False,
label=_lazy(u'Toolbar'),
help_text=_lazy(u'Creates an example toolbar for your extension'))
toolbar_button = forms.BooleanField(
required=False,
label=_lazy(u'Toolbar button'),
help_text=_lazy(u'Creates an example button on the browser '
'toolbar'))
main_menu_command = forms.BooleanField(
required=False,
label=_lazy(u'Main menu command'),
help_text=_lazy(u'Creates an item on the Tools menu'))
context_menu_command = forms.BooleanField(
required=False,
label=_lazy(u'Context menu command'),
help_text=_lazy(u'Creates a context menu item for images'))
sidebar_support = forms.BooleanField(
required=False,
label=_lazy(u'Sidebar support'),
help_text=_lazy(u'Creates an example sidebar panel'))
class CheckCompatibilityForm(happyforms.Form):
application = forms.ChoiceField(
label=_lazy(u'Application'),
choices=[(a.id, a.pretty) for a in amo.APP_USAGE])
app_version = forms.ChoiceField(
label=_lazy(u'Version'),
choices=[('', _lazy(u'Select an application first'))])
def __init__(self, *args, **kw):
super(CheckCompatibilityForm, self).__init__(*args, **kw)
w = self.fields['application'].widget
# Get the URL after the urlconf has loaded.
w.attrs['data-url'] = reverse('devhub.compat_application_versions')
def version_choices_for_app_id(self, app_id):
versions = AppVersion.objects.filter(application__id=app_id)
return [(v.id, v.version) for v in versions]
def clean_application(self):
app_id = int(self.cleaned_data['application'])
app = Application.objects.get(pk=app_id)
self.cleaned_data['application'] = app
choices = self.version_choices_for_app_id(app_id)
self.fields['app_version'].choices = choices
return self.cleaned_data['application']
def clean_app_version(self):
v = self.cleaned_data['app_version']
return AppVersion.objects.get(pk=int(v))
class NewManifestForm(happyforms.Form):
manifest = forms.URLField(verify_exists=False)
def clean_manifest(self):
manifest = self.cleaned_data['manifest']
verify_app_domain(manifest)
return manifest
UPSELL_CHOICES = (
(0, _lazy("I don't have a free add-on to associate.")),
(1, _lazy('This is a premium upgrade to:')),
)
APP_UPSELL_CHOICES = (
(0, _lazy("I don't have a free app to associate.")),
(1, _lazy('This is a premium upgrade to:')),
)
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()
def DependencyFormSet(*args, **kw):
addon_parent = kw.pop('addon')
# Add-ons: Required add-ons cannot include apps nor personas.
# Apps: Required apps cannot include any add-ons.
qs = Addon.objects.reviewed().exclude(id=addon_parent.id)
if addon_parent.is_webapp():
qs = qs.filter(type=amo.ADDON_WEBAPP)
else:
qs = qs.exclude(type__in=[amo.ADDON_PERSONA, amo.ADDON_WEBAPP])
class _Form(happyforms.ModelForm):
addon = forms.CharField(required=False, widget=forms.HiddenInput)
dependent_addon = forms.ModelChoiceField(qs, widget=forms.HiddenInput)
class Meta:
model = AddonDependency
fields = ('addon', 'dependent_addon')
def clean_addon(self):
return addon_parent
class _FormSet(BaseModelFormSet):
def clean(self):
if any(self.errors):
return
form_count = len([f for f in self.forms
if not f.cleaned_data.get('DELETE', False)])
if form_count > 3:
if addon_parent.is_webapp():
error = loc('There cannot be more than 3 required apps.')
else:
error = _('There cannot be more than 3 required add-ons.')
raise forms.ValidationError(error)
FormSet = modelformset_factory(AddonDependency, formset=_FormSet,
form=_Form, extra=0, can_delete=True)
return FormSet(*args, **kw)