class AccountForm(forms.Form, ManualFormHelpers):
name = forms.CharField(
label="Company / Organization",
min_length=2,
max_length=30,
)
timezone = forms.ChoiceField(label="Time zone",
choices=settings.ACCOUNT_TIME_ZONES)
subdomain = forms.CharField(
min_length=2,
max_length=30,
)
domain = forms.ChoiceField(choices=settings.ACCOUNT_DOMAINS)
def clean_subdomain(self):
if not self.cleaned_data['subdomain'].isalnum():
raise forms.ValidationError(
"Your subdomain can only include letters and numbers.")
return self.cleaned_data['subdomain']
def update_account(self, account):
for n in ['name', 'subdomain', 'domain', 'timezone']:
setattr(account, n, self.cleaned_data[n])
if not account.validate():
account.save()
return account
else:
logging.debug(str(account.subscription_level_id))
logging.debug('UPDATE_ACCOUNT validation errors: %s' %
str(account.validate()))
raise ValueError
class PostForm(djangoforms.ModelForm):
# log = logging.getLogger()
title = forms.CharField(widget=forms.TextInput(attrs={'id':'name'}))
body = forms.CharField(widget=forms.Textarea(attrs={
'id':'message',
'rows': 10,
'cols': 20}))
body_markup = forms.ChoiceField(
choices=[(k, v[0]) for k, v in markup.MARKUP_MAP.iteritems()])
tags = forms.CharField(widget=forms.Textarea(attrs={'rows': 5, 'cols': 20}))
draft = forms.BooleanField(required=False)
image_url = forms.CharField(required=False, widget=forms.TextInput(attrs={'id':'image_url'}))
if common.PROD:
url = '%s/api/authors' % (config.main_site_origin)
else:
url = '%s/api/authors' % (config.main_site_test_origin)
sorted_profiles = []
try:
response = urlfetch.fetch(url)
if response.status_code == 200:
sorted_profiles = simplejson.loads(response.content).keys()
except urlfetch.DownloadError:
pass
author_id = forms.ChoiceField(
choices=[(id,id) for id in sorted_profiles])
IMAGE_STYLES = (('top','top'), ('left','left'), ('right','right'))
image_style = forms.ChoiceField(required=False, choices=IMAGE_STYLES)
class Meta:
model = models.BlogPost
fields = [ 'title', 'body', 'tags', 'author_id', 'image_url', 'image_style' ]
class inputForm(forms.Form):
betType = forms.ChoiceField(choices=BETTYPE_CHOICES,
label='Betting Strategy')
nDeck = forms.ChoiceField(choices=NDECK_CHOICES, label='Number of Decks')
nSim = forms.ChoiceField(choices=NSIM_CHOICES,
label='Number of Simulation')
minimumBet = forms.ChoiceField(choices=MINIMUM, label='Minimum Bet')
maximumBet = forms.ChoiceField(choices=MAXIMUM, label='Maximum Bet')
class ScheduleBuilderForm(forms.Form):
_courses = [(c.id, str(c)) for c in Course.objects.filter(current=True)]
_hours = [(x, "%s:00" % (x % 12)) for x in [8,9,10,11,13,14,15,16]]
_lengths = [(x, "%s hours" % x) for x in [1,2,3,4]]
_instructors = [(p.instructor_letter, str(p)) for p in Person.objects.filter(kind=FACULTY_KIND)]
_rooms = [(r.id, str(r)) for r in Room.objects.all()]
course = forms.ChoiceField(choices=_courses)
start_time = forms.ChoiceField(choices=_hours)
length = forms.ChoiceField(choices=_lengths)
room = forms.ChoiceField(choices=_rooms)
sections = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple, choices=SECTION_CHOICES)
instructors = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple, choices=_instructors, required=False)
class DataqueryForm(forms.Form):
FORMAT="%Y-%m-%d %H:%M:%S"
td=datetime.datetime.utcnow()
NOW=td.strftime(FORMAT)
yd = datetime.datetime.utcnow() - datetime.timedelta(1)
YESTERDAY=yd.strftime(FORMAT)
starttime = forms.DateTimeField( initial=YESTERDAY)
endtime = forms.DateTimeField( initial=NOW)
sitename = forms.ChoiceField(choices=SITE_CHOICES)
datatype = forms.ChoiceField(choices=DTYPE_CHOICES, initial="counts")
class AnalysisForm(forms.Form):
FORMAT="%Y-%m-%d %H:%M:%S"
td=datetime.datetime.utcnow()
NOW=td.strftime(FORMAT)
yd = datetime.datetime.utcnow() - datetime.timedelta(1)
YESTERDAY=yd.strftime(FORMAT)
starttime = forms.DateTimeField( label="Start Time", initial=YESTERDAY)
endtime = forms.DateTimeField( label="End Time", initial=NOW)
sitename = forms.ChoiceField(label="Site Name", choices=SITE_CHOICES)
format = forms.ChoiceField(label="Output Format", choices=FORMAT_CHOICES, initial="txt")
datatype = forms.ChoiceField(label="Data Type" , choices=ATYPE_CHOICES, initial="counts")
filtertype = forms.ChoiceField(label="Processing Type", choices=FILTER_CHOICES, initial="avg")
interval = forms.IntegerField(label="Averaging Interval (minutes)", initial=30)
def __init__(self, listChoices, sortChoices, *args, **kwargs):
debugOutput("Creating")
super(FieldConfigForm, self).__init__(*args, **kwargs)
self.fields["field_type"] = newforms.ChoiceField(
required=True,
choices=listChoices) #, widget=newforms.RadioSelect)
self.fields["list_sort"] = newforms.ChoiceField(
required=True,
choices=sortChoices) #, widget=newforms.RadioSelect)
self.fields["list_values"] = newforms.CharField(
required=False,
widget=newforms.Textarea(attrs={
"cols": 35,
"rows": 15
}))
def __init__(self, countries, areas, *args, **kwargs):
super(ContactInfoForm, self).__init__(*args, **kwargs)
if areas is not None and countries is None:
self.fields['state'] = forms.ChoiceField(choices=areas, initial=selection)
self.fields['ship_state'] = forms.ChoiceField(choices=areas, initial=selection, required=False)
if countries is not None:
self.fields['country'] = forms.ChoiceField(choices=countries)
shop_config = Config.get_shop_config()
self._local_only = shop_config.in_country_only
country = shop_config.sales_country
if not country:
self._default_country = 'US'
else:
self._default_country = country.iso2_code
def __init__(self, *args, **kwargs):
products = kwargs.pop('products', None)
super(ProductExportForm, self).__init__(*args, **kwargs)
self.fields['format'] = forms.ChoiceField(label=_('export format'),
choices=export_choices(),
required=True)
self.fields['include_images'] = forms.BooleanField(
label=_('Include Images'), initial=True, required=False)
if not products:
products = Product.objects.all().order_by('slug')
for product in products:
subtypes = product.get_subtypes()
expclasses = ('export', ) + subtypes
extclasses = " ".join(expclasses)
kw = {
'label': product.slug,
'help_text': product.name,
'initial': False,
'required': False,
'widget': forms.CheckboxInput(attrs={'class': extclasses})
}
chk = forms.BooleanField(**kw)
chk.slug = product.slug
chk.product_id = product.id
chk.subtypes = " ".join(subtypes)
self.fields['export__%s' % product.slug] = chk
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.tempCart = Cart.objects.get(id=request.session['cart'])
self.tempContact = Contact.from_request(request)
shipping_choices, shipping_dict = _get_shipping_choices(
paymentmodule, self.tempCart, self.tempContact)
self.fields['shipping'].choices = shipping_choices
self.shipping_dict = shipping_dict
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)
if not valid:
raise forms.ValidationError(msg)
# TODO: validate that it can work with these products
return data
class ApplianceForm(forms.Form):
url = forms.URLField()
email = forms.EmailField()
appliance_type = forms.ChoiceField(choices = [('', 'Unknown'),
('EC2', 'Amazon EC2'),
('VMX', 'VMware'),
('Devel', 'Development')])
def __init__(self, *args, **kwargs):
debugOutput("Creating")
super(self.__class__, self).__init__(*args, **kwargs)
# Get a list of contexts.
types = []
wikidbaseContexts = wikidbase.core.context.getContexts()
for nContext in wikidbaseContexts:
types.append(wikidbaseContexts[nContext].contextNameVariations.
getMostCommon())
types = [(x, x.capitalize()) for x in types]
self.fields["relationtypea"] = newforms.ChoiceField(choices=types,
required=False)
self.fields["relationtypeb"] = newforms.ChoiceField(choices=types,
required=False)
self.fields["relationnamea"] = newforms.CharField(required=False)
self.fields["relationnameb"] = newforms.CharField(required=False)
class EmailForm(forms.Form):
FromName = forms.CharField(initial='MedCommons')
FromEmail = forms.EmailField( \
initial = '*****@*****.**',
help_text = "Emails to users are from this email address")
IncomingEmailEnabled = forms.ChoiceField(
choices=[('0', 'Disabled'), ('1', 'Enabled')],
help_text="Enables incoming email of the form {mcid}@{domain name}")
class SettingsForm(forms.Form):
# AccountStatus = forms.CharField()
# PrivacyConfigurationFile = forms.CharField()
# PrivacyPolicyFile = forms.CharField()
# PatientBrochureFile = forms.CharField()
# TemporaryAccountRetentionTime = forms.CharField()
ApplianceMode = forms.ChoiceField(choices=[('0', 'Development'),
('1', 'Test'), ('2', 'Demo'),
('3', 'Production')],
initial='0')
OnlineRegistration = forms.ChoiceField(
choices=[('0', 'Disabled'), ('1', 'Enabled')],
help_text="Can new users register online")
OpenIDMode = forms.ChoiceField(
choices=[('0', 'Disabled'), ('1', 'Whitelist'), ('2', 'Open')],
initial='0',
help_text='Which OpenID logins are accepted')
class EditBotForm(forms.Form):
filter_mode = forms.ChoiceField(
choices = models.filter_mode_choices,
widget = forms.RadioSelect,
)
project_list = forms.CharField(
required = False,
widget = forms.Textarea,
)
show_project_names = forms.BooleanField(
required = False,
widget = forms.CheckboxInput(attrs = {'class': 'checkbox'}),
)
def __init__(self, data=None):
forms.Form.__init__(self, data)
self.filter_modes = formtools.RadioChoices(self['filter_mode'], models.FILTER)
def clean_filter_mode(self):
return int(self.cleaned_data['filter_mode'])
def clean_project_list(self):
# Remove extra whitespace, split into individual projects.
projects = []
for line in self.cleaned_data['project_list'].split('\n'):
line = line.strip()
if line:
projects.append(line)
# Is the project list required?
if int(self.data['filter_mode']) == models.FILTER.PROJECT_LIST and not projects:
raise forms.ValidationError("Please enter at least one project.")
return '\n'.join(projects)
custom_ruleset = forms.CharField(
required = False,
widget = forms.Textarea,
)
def clean_custom_ruleset(self):
# Empty rulesets are okay if we aren't using them. We never
# allow a ruleset to be stored if it isn't well-formed and
# valid.
allow_empty = int(self.data['filter_mode']) != models.FILTER.CUSTOM
# Use LibCIA to validate the ruleset. It would be nice to
# hilight errors, or even interactively validate rulesets on
# the client side.. but this is sufficient for now.
return models.validate_ruleset(self.cleaned_data['custom_ruleset'], allow_empty)
def apply(self, cset):
cset.set_field_dict(self.cleaned_data)
cset.asset.syncToServer()
class FormatForm(forms.Form):
canonical = forms.BooleanField(required=False)
explicit_start = forms.BooleanField(required=False)
explicit_end = forms.BooleanField(required=False)
allow_unicode = forms.BooleanField(required=False)
styles = [(0, 'Default'), ('"', 'Double quote - "'),
("'", "Single quote - '")]
default_style = forms.ChoiceField(choices=styles)
flow_styles = [(1, 'Default'), (2, 'Block style'), (3, "Flow style")]
default_flow_style = forms.ChoiceField(choices=flow_styles)
indents = [(1, '1'), (2, '2'), (4, '4'), (8, '8')]
indent = forms.ChoiceField(choices=indents, initial='4')
widths = [(20, '20'), (40, '40'), (60, '60'), (80, '80'), (100, '100'),
(120, '120')]
width = forms.ChoiceField(choices=widths)
versions = [(0, '1.0'), (1, '1.1')]
yaml_version = forms.ChoiceField(choices=versions)
show_version = forms.BooleanField(required=False)
show_events = forms.BooleanField(required=False)
show_tokens = forms.BooleanField(required=False)
show_node = forms.BooleanField(required=False)
class PaymentContactInfoForm(ContactInfoForm):
_choices = payment_choices()
if len(_choices) > 0:
if len(_choices) > 1:
_paymentwidget = forms.RadioSelect
else:
_paymentwidget = forms.HiddenInput(attrs={'value': _choices[0][0]})
paymentmethod = forms.ChoiceField(label=_('Payment method'),
choices=_choices,
widget=_paymentwidget,
required=True)
class CreateConfigForm(BaseConfigForm):
type = forms.ChoiceField(
widget=forms.widgets.Select(attrs={'id':"imagetype"}),
choices=(
("kernel", "Linux Kernel"),
("image", "Raw image file"),
("memdisk", "Disk image"),
("iso", "CD ISO Image")),
initial="kernel")
kernel = forms.URLField(widget=forms.widgets.TextInput(attrs={'id':"kernel"}),
label="Kernel/Image")
initrd = forms.URLField(widget=forms.widgets.TextInput(attrs={'id':"initrd"}),
required=False)
args = forms.CharField(widget=forms.widgets.TextInput(attrs={'id':"args"}),
required=False)
#------------------------------------------------------------------------------
class ReportsForm(forms.Form):
"Класс формы для отчета"
report_kind = forms.ChoiceField(label="Вид отчета", choices=REPORT_KINDS, help_text="Выберите вид отчета")
# device = forms.ModelChoiceField(queryset=Device.objects.filter())
interval_begin = forms.DateTimeField(label="Начало периода", widget=forms.TextInput(attrs={"class" : "vDateField"}), help_text="гггг-мм-дд чч:мм:сс")
interval_end = forms.DateTimeField(label="Конец периода", widget=forms.TextInput(attrs={"class" : "vDateField"}), help_text="гггг-мм-дд чч:мм:сс")
speed_limit = forms.IntegerField(label="Ограничение скорости", initial=72, help_text="скорость в км/ч")
def __init__(self, account, *args, **kwargs):
"""
Конструктор переопределен для создания поля "device",
список значений для которого фильтруется в соответствии с текущим Аккаунтом
"""
super(ReportsForm, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
debugOutput("Creating")
if "fields" in kwargs and kwargs["fields"]:
fields = kwargs["fields"]
del kwargs["fields"]
else:
fields = []
super(self.__class__, self).__init__(*args, **kwargs)
choices = [("above__" + nField, "Above " + fields[nField])
for nField in fields]
choices.append(("bottom", "Bellow all fields"))
self.fields["position"] = newforms.ChoiceField(choices=choices,
required=True)
class PostForm(djangoforms.ModelForm):
title = forms.CharField(widget=forms.TextInput(attrs={'id': 'name'}))
body = forms.CharField(widget=forms.Textarea(attrs={
'id': 'message',
'rows': 10,
'cols': 20
}))
body_markup = forms.ChoiceField(
choices=[(k, v[0]) for k, v in markup.MARKUP_MAP.iteritems()])
tags = forms.CharField(widget=forms.Textarea(attrs={
'rows': 5,
'cols': 20
}))
draft = forms.BooleanField(required=False)
class Meta:
model = models.BlogPost
fields = ['title', 'body', 'tags']
class QuestionForm(forms.Form):
answers = forms.ChoiceField(widget=forms.RadioSelect(), label=u"Please select a answer:")
def __init__(self, question, *args, **kwargs):
super(QuestionForm, self).__init__(*args, **kwargs)
self.question = question.question
answers = question.answers.order_by('weight')
self.fields['answers'].choices = [(i, a.answer) for i, a in enumerate(answers)]
for pos, answer in enumerate(answers):
if answer.id == question.correct_answer_id:
self.correct = pos
break
def is_correct(self):
if not self.is_valid():
return False
return self.cleaned_data['answers'] == str(self.correct)
class PageForm(djangoforms.ModelForm):
path = forms.RegexField(
widget=forms.TextInput(attrs={'id':'path'}),
regex='(/[a-zA-Z0-9/]+)')
title = forms.CharField(widget=forms.TextInput(attrs={'id':'title'}))
template = forms.ChoiceField(choices=config.page_templates.items())
body = forms.CharField(widget=forms.Textarea(attrs={
'id':'body',
'rows': 10,
'cols': 20}))
class Meta:
model = models.Page
fields = [ 'path', 'title', 'template', 'body' ]
def clean_path(self):
data = self._cleaned_data()['path']
existing_page = models.Page.get_by_key_name(data)
if not data and existing_page:
raise forms.ValidationError("The given path already exists.")
return data
def customized_editor(user, settings):
"Customize the setting editor based on the current user and setting list"
base_fields = SortedDict()
for setting in settings:
perm = '%s.can_edit_%s_settings' % (setting.module_name.split('.')[-2],
setting.class_name.lower())
if user.has_perm(perm):
# Add the field to the customized field list
storage = get_setting_storage(*setting.key)
kwargs = {
'label': setting.description,
'help_text': setting.help_text,
# Provide current setting values for initializing the form
'initial': setting.to_editor(storage.value),
}
if setting.choices:
field = forms.ChoiceField(choices=setting.choices, **kwargs)
else:
field = setting.field(**kwargs)
base_fields['%s__%s__%s' % setting.key] = field
return type('SettingsEditor', (SettingsEditor, ),
{'base_fields': base_fields})
class MoveNodeForm(forms.Form):
"""
A form which allows the user to move a given node from one location
in its tree to another, with optional restriction of the nodes which
are valid target nodes for the move.
"""
POSITION_FIRST_CHILD = 'first-child'
POSITION_LAST_CHILD = 'last-child'
POSITION_LEFT = 'left'
POSITION_RIGHT = 'right'
POSITION_CHOICES = (
(POSITION_FIRST_CHILD, _('First child')),
(POSITION_LAST_CHILD, _('Last child')),
(POSITION_LEFT, _('Left sibling')),
(POSITION_RIGHT, _('Right sibling')),
)
target = forms.ModelChoiceField(queryset=None)
position = forms.ChoiceField(choices=POSITION_CHOICES,
initial=POSITION_FIRST_CHILD)
def __init__(self, node, *args, **kwargs):
"""
The ``node`` to be moved must be provided. The following keyword
arguments are also accepted::
``valid_targets``
Specifies a ``QuerySet`` of valid targets for the move. If
not provided, valid targets will consist of everything other
node of the same type, apart from the node itself and any
descendants.
For example, if you want to restrict the node to moving
within its own tree, pass a ``QuerySet`` containing
everything in the node's tree except itself and its
descendants (to prevent invalid moves) and the root node (as
a user could choose to make the node a sibling of the root
node).
``target_select_size``
The size of the select element used for the target node.
Defaults to ``10``.
"""
valid_targets = kwargs.pop('valid_targets', None)
target_select_size = kwargs.pop('target_select_size', 10)
super(MoveNodeForm, self).__init__(*args, **kwargs)
self.node = node
opts = node._meta
if valid_targets is None:
valid_targets = node._tree_manager.exclude(
**{
opts.tree_id_attr: getattr(node, opts.tree_id_attr),
'%s__gte' % opts.left_attr: getattr(node, opts.left_attr),
'%s__lte' % opts.right_attr: getattr(
node, opts.right_attr),
})
self.fields['target'].queryset = valid_targets
self.fields['target'].choices = \
[(target.pk, '%s %s' % ('---' * getattr(target, opts.level_attr),
unicode(target)))
for target in valid_targets]
self.fields['target'].widget.attrs['size'] = target_select_size
def save(self):
"""
Attempts to move the node using the selected target and
position.
If an invalid move is attempted, the related error message will
be added to the form's non-field errors and the error will be
re-raised. Callers should attempt to catch ``InvalidNode`` to
redisplay the form with the error, should it occur.
"""
try:
self.node.move_to(self.cleaned_data['target'],
self.cleaned_data['position'])
return self.node
except InvalidMove, e:
self.errors[NON_FIELD_ERRORS] = ErrorList(e)
raise
def choice_field(self, **kwargs):
if self.hidden:
kwargs['widget'] = forms.MultipleHiddenInput()
return forms.ChoiceField(choices=self.choices, **kwargs)
class CreditPayShipForm(forms.Form):
credit_type = forms.ChoiceField()
credit_number = forms.CharField(max_length=20)
month_expires = forms.ChoiceField(choices=[(month, month)
for month in range(1, 13)])
year_expires = forms.ChoiceField()
ccv = forms.IntegerField() # find min_length
shipping = forms.ChoiceField(widget=forms.RadioSelect(), required=False)
discount = forms.CharField(max_length=30, required=False)
def __init__(self, request, paymentmodule, *args, **kwargs):
creditchoices = paymentmodule.CREDITCHOICES.choice_values
super(CreditPayShipForm, self).__init__(*args, **kwargs)
self.fields['credit_type'].choices = creditchoices
year_now = datetime.date.today().year
self.fields['year_expires'].choices = [
(year, year) for year in range(year_now, year_now + 6)
]
self.tempCart = Cart.objects.get(id=request.session['cart'])
self.tempContact = Contact.from_request(request)
shipping_choices, shipping_dict = _get_shipping_choices(
paymentmodule, self.tempCart, self.tempContact)
self.fields['shipping'].choices = shipping_choices
self.shipping_dict = shipping_dict
def clean_credit_number(self):
""" Check if credit card is valid. """
credit_number = self.cleaned_data['credit_number']
card = CreditCard(credit_number, self.cleaned_data['credit_type'])
results, msg = card.verifyCardTypeandNumber()
if not results:
raise forms.ValidationError(msg)
return credit_number
def clean_month_expires(self):
return int(self.cleaned_data['month_expires'])
def clean_year_expires(self):
""" Check if credit card has expired. """
month = self.cleaned_data['month_expires']
year = int(self.cleaned_data['year_expires'])
max_day = calendar.monthrange(year, month)[1]
if datetime.date.today() > datetime.date(
year=year, month=month, day=max_day):
raise forms.ValidationError(_('Your card has expired.'))
return year
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 if it applies to these products """
data = self.cleaned_data['discount']
if data:
discount = Discount.objects.filter(code=data).filter(active=True)
if discount.count() == 0:
raise forms.ValidationError(_('Invalid discount.'))
valid, msg = discount[0].isValid(self.tempCart)
if not valid:
raise forms.ValidationError(msg)
return data
class SignupForm(forms.Form, SavesPayment):
def __init__(self, requires_payment, *args, **kwargs):
self.requires_payment = requires_payment
forms.Form.__init__(self, *args, **kwargs)
if not requires_payment:
del self.fields['card_number']
del self.fields['card_expiration']
first_name = forms.CharField(
label="First name",
min_length=2,
max_length=30,
)
last_name = forms.CharField(
label="Last name",
min_length=2,
max_length=30,
)
email = forms.EmailField(label="Email", )
username = forms.CharField(
label="Username",
help_text="You'll use this to log in",
min_length=4,
max_length=30,
)
password = forms.CharField(label="Password",
min_length=6,
max_length=20,
widget=forms.PasswordInput())
password2 = forms.CharField(
label="Password again",
help_text="Confirm your password by entering it again",
min_length=6,
max_length=20,
widget=forms.PasswordInput())
group = forms.CharField(
label="Company / Organization",
min_length=2,
max_length=30,
)
timezone = forms.ChoiceField(
label="Time zone",
choices=settings.ACCOUNT_TIME_ZONES,
initial=settings.ACCOUNT_DEFAULT_TIME_ZONE,
)
# Domain must come BEFORE subdomain. Cleaning order is important.
domain = forms.ChoiceField(choices=settings.ACCOUNT_DOMAINS)
subdomain = forms.CharField(
min_length=2,
max_length=30,
)
#card_type = forms.ChoiceField(
#label = "Card type",
#choices = enumerate(['Visa', 'Mastercard', 'AmericanExpress']),
#required = False,
#)
card_number = forms.CharField(
label="Card number",
required=False,
)
card_expiration = forms.DateField(
label="Expiration",
required=False,
)
terms_of_service = forms.BooleanField(
label="I agree to the Terms of Service, Refund, and Privacy policies")
def clean_password2(self):
if self.cleaned_data['password'] != self.cleaned_data['password2']:
raise forms.ValidationError(
"The two passwords didn't match. Please try again.")
return self.cleaned_data['password2']
def clean_subdomain(self):
if not self.cleaned_data['subdomain'].isalnum():
raise forms.ValidationError(
"Your subdomain can only include letters and numbers.")
try:
Account.objects.get(
subdomain=self.cleaned_data['subdomain'],
domain=self.data['domain'],
)
raise forms.ValidationError(
"The domain %s.%s has already been taken" %
(self.cleaned_data['subdomain'], self.cleaned_data['domain']))
except Account.DoesNotExist:
pass
return self.cleaned_data['subdomain']
def clean_terms_of_service(self):
if not self.cleaned_data['terms_of_service']:
raise forms.ValidationError(
"Sorry, but we can't create your account unless you accept the terms of service."
)
def save_account(self, level):
account = Account(
domain=self.cleaned_data['domain'],
subdomain=self.cleaned_data['subdomain'],
timezone=self.cleaned_data['timezone'],
name=self.cleaned_data['group'],
subscription_level_id=level,
)
if not account.validate():
account.save()
return account
else:
raise ValueError
def save_person(self, account):
person = Person(
account=account,
username=self.cleaned_data['username'],
first_name=self.cleaned_data['first_name'],
last_name=self.cleaned_data['last_name'],
email=self.cleaned_data['email'],
)
person.set_password(self.cleaned_data['password'])
if not person.validate():
person.save()
return person
else:
raise ValueError
class ContactForm(forms.Form):
name = forms.CharField(label=_("Name"), max_length=100)
sender = forms.EmailField(label=_("Email address"))
subject = forms.CharField(label=_("Subject"))
inquiry = forms.ChoiceField(label=_("Inquiry"), choices=email_choices)
contents = forms.CharField(label=_("Contents"), widget=widgets.Textarea(attrs = {'cols': 40, 'rows': 5}))
class EditAssetForm(forms.Form):
access = forms.ChoiceField(
choices=models.access_choices,
widget=forms.RadioSelect,
)
def __init__(self, data=None):
forms.Form.__init__(self, data)
self.access_levels = formtools.RadioChoices(self['access'],
models.ACCESS)
def clean_access(self):
return int(self.cleaned_data['access'])
def should_delete(self):
"""Are we removing access to this asset?"""
return self.cleaned_data['access'] == models.ACCESS.NONE
def delete(self, request, user_asset):
"""Delete this UserAsset, create a message indicating that we
were successful, then redirect back to the 'add' page.
"""
user_asset.delete()
request.user.message_set.create(message="Removed access to %s" %
user_asset.asset)
return HttpResponseRedirect("/account/%s/add/" %
user_asset.asset._meta.asset_type)
def apply(self, cset, request, user_asset):
"""Apply changes to a UserAsset, saving information about
those changes in the provided changeset.
"""
new_access = self.cleaned_data['access']
if new_access != user_asset.access:
if new_access == models.ACCESS.NONE:
# We'll actually do the deletion later
cset.set_meta('_lost_access')
elif new_access == models.ACCESS.COMMUNITY:
# Decreasing the access level
request.user.message_set.create(
message="You now have community-level access to %s" %
user_asset.asset)
assert user_asset.access > new_access
cset.set_meta('_community_access')
user_asset.access = new_access
user_asset.save()
elif new_access == models.ACCESS.EXCLUSIVE:
# Increasting the access level. Gaining exclusive
# access also means revoking access from any other
# (community-access) users!
request.user.message_set.create(
message="You have taken exclusive access to %s" %
user_asset.asset)
cset.set_meta('_exclusive_access')
user_asset.access = new_access
user_asset.save()
user_asset.asset.assets.exclude(user=request.user).delete()
