class OrganizationPaymentForm(forms.ModelForm):
disconnect_stripe_live = forms.BooleanField(required=False)
disconnect_stripe_test = forms.BooleanField(required=False)
class Meta:
model = Organization
fields = (
'check_payment_allowed',
'check_payable_to',
'check_recipient',
'check_address',
'check_address_2',
'check_city',
'check_state_or_province',
'check_zip',
'check_country',
)
widgets = {
'check_country': forms.Select,
}
def __init__(self, request, *args, **kwargs):
super(OrganizationPaymentForm, self).__init__(*args, **kwargs)
if not self.instance.stripe_live_connected():
del self.fields['disconnect_stripe_live']
if not self.instance.stripe_test_connected():
del self.fields['disconnect_stripe_test']
self.request = request
if self.instance.pk is None:
self.instance.owner = request.user
def clean_check_payment_allowed(self):
cpa = self.cleaned_data['check_payment_allowed']
if cpa:
for field in ('check_payable_to', 'check_recipient',
'check_address', 'check_city', 'check_zip',
'check_state_or_province', 'check_country'):
self.fields[field].required = True
return cpa
def clean(self):
cleaned_data = super(OrganizationPaymentForm, self).clean()
if 'check_zip' in cleaned_data:
country = self.instance.check_country
code = cleaned_data['check_zip']
try:
cleaned_data['check_zip'] = clean_postal_code(country, code)
except ValidationError, e:
del cleaned_data['check_zip']
self.add_error('check_zip', e)
return cleaned_data
class JobSearchForm(forms.Form):
q = forms.CharField(
label='What',
required=False,
widget=forms.TextInput(
attrs={
'class': 'form-control',
'placeholder': 'job title, keywords or tags',
}),
)
l = forms.CharField(
label='Where',
required=False,
widget=forms.TextInput(
attrs={
'class': 'form-control',
'placeholder': 'job title, keywords or tags',
}),
)
is_visual_impairment_accepted = forms.BooleanField(
label='visual disabilities', required=False, initial=False)
is_hearing_impairment_accepted = forms.BooleanField(
label='hearing disabilities', required=False, initial=False)
is_motor_impairment_accepted = forms.BooleanField(
label='motor disabilities', required=False, initial=False)
def search(self, jobs):
q = self.cleaned_data.get('q')
if q:
jobs = jobs.filter(title__icontains=q)
l = self.cleaned_data.get('l')
if l:
jobs = jobs.filter(location__icontains=l)
impairements_filter = {}
for name in [
'visual',
'hearing',
'motor',
]:
impairment = 'is_{}_impairment_accepted'.format(name)
value = self.cleaned_data.get(impairment)
if value:
impairements_filter[impairment] = value
if impairements_filter:
jobs = jobs.filter(**impairements_filter)
return jobs
class EditFragmentForm(BaseFragmentForm):
"""Edit fragment"""
delete_me = floppyforms.BooleanField(label=_("delete"), required=False)
class Meta:
model = Fragment
fields = (
'type',
'filter',
'name',
'css_class',
'position',
)
widgets = {
"type": forms.HiddenInput(),
"filter": forms.HiddenInput(),
}
def __init__(self, *args, **kwargs):
instance = kwargs.get('instance', None)
if instance:
instance.css_class = instance.css_class.split(" ")
super(EditFragmentForm, self).__init__(*args, **kwargs) # pylint: disable=E1002
self.post_init()
def save(self, *args, **kwargs):
"""delete """
if self.cleaned_data['delete_me']:
self.instance.delete()
return None
return super(EditFragmentForm, self).save(*args, **kwargs) # pylint: disable=E1002
class PostalReplyForm(PostalBaseForm):
FIELD_ORDER = [
'public_body', 'sender', 'date', 'subject', 'text', 'files',
'not_publishable'
]
PUBLIC_BODY_LABEL = _('Sender public body')
sender = forms.CharField(
label=_("Sender name"),
widget=forms.TextInput(attrs={
"class": "form-control",
"placeholder": _("Sender Name")
}),
required=True)
not_publishable = forms.BooleanField(
label=_("You are not allowed to publish some received documents"),
initial=False,
required=False,
help_text=
_('If the reply explicitly states that you are not allowed to publish some of the documents (e.g. due to copyright), check this.'
))
def contribute_to_message(self, message):
message.is_response = True
message.sender_name = self.cleaned_data['sender']
message.sender_public_body = message.request.public_body
message.not_publishable = self.cleaned_data['not_publishable']
return message
class TermsForm(forms.Form):
terms = forms.BooleanField(
label=mark_safe(_("Terms and Conditions and Privacy Statement")),
error_messages={
'required':
_('You need to accept our Terms and Conditions and Priavcy Statement.'
)
},
widget=AgreeCheckboxInput(agree_to=_(
u'You agree to our <a href="%(url_terms)s" class="target-new">Terms and Conditions</a> and <a href="%(url_privacy)s" class="target-new">Privacy Statement</a>'
),
url_names={
"url_terms": "help-terms",
"url_privacy": "help-privacy"
}))
def __init__(self, *args, **kwargs):
super(TermsForm, self).__init__(*args, **kwargs)
if HAVE_NEWSLETTER():
self.fields['newsletter'] = forms.BooleanField(
required=False,
label=_("Check if you want to receive our newsletter."))
def save(self, user):
user.terms = True
if HAVE_NEWSLETTER():
user.newsletter = self.cleaned_data['newsletter']
user.save()
class OneTimePaymentForm(BasePaymentForm, AddCardForm):
save_card = forms.BooleanField(required=False)
def __init__(self, order, *args, **kwargs):
super(OneTimePaymentForm, self).__init__(order=order,
api_type=order.event.api_type,
*args,
**kwargs)
if not self.user.is_authenticated():
del self.fields['save_card']
def _post_clean(self):
kwargs = {
'amount': self.amount,
'event': self.order.event,
'order': self.order,
}
try:
if self.cleaned_data.get('save_card'):
self.card = self.add_card(self.cleaned_data['token'])
self._charge = stripe_charge(self.card.id,
customer=self.customer,
**kwargs)
else:
self._charge = stripe_charge(self.cleaned_data['token'],
**kwargs)
self.card = self._charge.source
except stripe.error.CardError, e:
self.add_error(None, e.message)
except stripe.error.APIError, e:
self.add_error(None, STRIPE_API_ERROR)
def __init__(self, *args, **kwargs):
super(PermissionsForm, self).__init__(*args, **kwargs)
for role in Group.objects.all():
for feature in models.Feature.objects.all():
for permission in feature.permissions.all():
is_enabled = role.permissions.filter(
pk=permission.pk).exists()
name = '-'.join((role.name, feature.name, permission.name))
checkbox = forms.BooleanField(
required=False,
initial=is_enabled,
)
checkbox.role = role
checkbox.permission = permission
self.fields[name] = checkbox
for feature in models.Feature.objects.all():
for permission in feature.permissions.all():
users = User.objects.filter(
user_permissions=permission).values_list('username',
flat=True)
users = '|'.join(users)
name = '%s-%s' % (permission.content_type_id,
permission.codename)
self.fields[name] = forms.CharField(required=False,
initial=users)
self.fields[name].permission = permission
class StudentWorkUpdatePublicForm(ParticipationCheckHiddenFormMixin,
forms.ModelForm):
text = forms.CharField(widget=FroalaEditor)
republish = forms.BooleanField(required=False)
class Meta:
model = StudentsWork
fields = ('title', 'text')
def __init__(self, user, *args, **kwargs):
super(UserChangeForm, self).__init__(*args, **kwargs)
self.user = user
self.fields['address'].initial = self.user.address
self.fields['email'].initial = self.user.email
if HAVE_NEWSLETTER():
self.fields['newsletter'] = forms.BooleanField(
required=False, label=_("Newsletter"))
self.fields['newsletter'].initial = self.user.newsletter
self.order_fields(self.field_order)
class PhotoGrid(forms.ModelForm):
fastUpload = forms.BooleanField(
widget=forms.CheckboxInput(attrs={'class': 'fastUploadClass'}),
required=False,
initial=False)
#rodalref = forms.BooleanField(widget=forms.CheckboxInput(attrs={'class': 'boolRodRef'}), required=False)
class Meta:
model = Report
fields = ('hide', )
class SimpleForm(forms.Form):
name = forms.CharField(
max_length=64, widget=widgets.TextInput(attrs={"placeholder": "Jane Doe"})
)
email = forms.CharField(
max_length=128,
widget=widgets.TextInput(attrs={"placeholder": "*****@*****.**"}),
)
tos = forms.BooleanField(
label="", widget=SwitchInput(), help_text="Terms of Service"
)
def __init__(self, *args, **kwargs):
super(InteractionsForm, self).__init__(*args, **kwargs)
grid = utils.get_role_grid()
for role1, others in grid:
for role2 in others:
for interaction in models.Interaction.objects.all():
is_permitted = interaction.is_permitted(role1, role2)
name = '-'.join((interaction.name, role1, role2))
checkbox = forms.BooleanField(
required=False,
initial=is_permitted,
)
checkbox.interaction = interaction
checkbox.role1 = Group.objects.get(name=role1)
checkbox.role2 = Group.objects.get(name=role2)
self.fields[name] = checkbox
class EULAForm(forms.Form):
""" Formulaire de validation des CGU """
# Constantes
CHOICES = ((False, _("I refuse to comply to the EULA and do not want to use this website")),
(True, _("I abide to the {website} EULA").format(website=get_website_name()))
)
# Champs
eula = forms_.BooleanField(required=True, label=_("EULA"), widget=forms.Select(choices=CHOICES))
# Initialiseur
def __init__(self, *args, **kwargs):
""" Initialiser le formulaire """
super(EULAForm, self).__init__(*args, **kwargs)
self.fields['eula'].error_messages = {'required': _("You must abide to the EULA to continue")}
class SubscribeContactsAdminForm(SearchActionForm):
"""This form is used for superuser forcing newsletter subscription"""
subscription_type = forms.ChoiceField(required=True)
subscribe = forms.BooleanField(
required=False, label=_('Subscribe'), help_text=_('It will subscribe/unsubscribe all selected contacts')
)
def __init__(self, *args, **kwargs):
super(SubscribeContactsAdminForm, self).__init__(*args, **kwargs)
self.fields['subscription_type'].choices = [
(subscription_type.id, subscription_type.name)
for subscription_type in SubscriptionType.objects.all()
]
def clean_subscription_type(self):
try:
return SubscriptionType.objects.get(id=self.cleaned_data['subscription_type'])
except SubscriptionType.DoesNotExist:
raise ValidationError(_('Unknown subscription type'))
class CancelLinesForm(forms.Form):
verify_ok = forms.BooleanField(initial=True, widget=forms.HiddenInput)
def clean_verify_ok(self):
if self.cleaned_data.get('verify_ok') is not True:
raise ValidationError(
_("Je moet goedkeuring geven om alle lijnen op te heffen"))
def __init__(self, *args, **kwargs):
super(CancelLinesForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_tag = 'journey_redbutton'
self.helper.layout = Layout(
Hidden('verify_ok', 'true'),
Submit(
'submit',
_("Hef alle ritten op"),
css_class="text-center btn-danger btn-tall col-sm-3 pull-right"
))
class SubscriptionForm(forms.Form):
subscribe = forms.BooleanField(label=_('Subscribe?'), required=False)
name = forms.CharField(label=_('Name'), required=False)
url = forms.URLField(label=_('URL'))
category = forms.ChoiceField(label=_('Category'), required=False)
def clean_url(self):
url = self.cleaned_data['url']
if (self.cleaned_data.get('subscribe', False)
and self.user.feeds.filter(url=url).exists()):
raise forms.ValidationError(
_("You are already subscribed to this feed."))
return url
def clean_name(self):
if (self.cleaned_data.get('subscribe', False)
and not self.cleaned_data['name']):
raise forms.ValidationError(_('This field is required.'))
return self.cleaned_data['name']
class GroupForContactsForm(forms.Form):
"""Add contacts to group"""
contacts = forms.CharField(widget=forms.HiddenInput())
groups = HidableModelMultipleChoiceField(queryset=Group.objects.all())
on_contact = forms.BooleanField(
label=_("Group on contact"),
required=False,
initial=True,
help_text=_("Define if the group is added on the contact itself or on his entity")
)
class Media:
"""media files"""
css = {
'all': ('chosen/chosen.css',)
}
js = (
'chosen/chosen.jquery.js',
)
def __init__(self, *args, **kwargs):
initial = kwargs.get('initial')
initial_contacts = ''
if initial and 'contacts' in initial:
initial_contacts = ';'.join(['{0}'.format(contact.id) for contact in initial['contacts']])
initial.pop('contacts')
super(GroupForContactsForm, self).__init__(*args, **kwargs)
if initial_contacts:
self.fields['contacts'].initial = initial_contacts
self.fields['groups'].widget.attrs = {
'class': 'chzn-select',
'data-placeholder': _('Select groups'),
'style': "width:350px;"
}
self.fields['groups'].help_text = ''
def get_contacts(self):
"""get contacts"""
contact_ids = self.cleaned_data["contacts"].split(";")
return Contact.objects.filter(id__in=contact_ids)
class LessonCopyForm(forms.Form):
copy_lessonsteps = forms.ModelMultipleChoiceField(
queryset=None,
widget=CheckboxSelectMultiple,
required=False
)
copy_lesson = forms.BooleanField(
required=False
)
def __init__(self, *args, **kwargs):
lesson_pk = kwargs.pop('lesson_pk', None)
self.lesson = get_object_or_404(Lesson, pk=lesson_pk)
super(LessonCopyForm, self).__init__(*args, **kwargs)
self.fields['copy_lessonsteps'].queryset = self.lesson.get_children()
def clean(self):
if not self.cleaned_data['copy_lesson']:
if (self.cleaned_data['copy_lessonsteps'] == []):
raise ValidationError('''Bitte etwas zum Kopieren auswählen!''')
def __init__(self, foirequest, *args, **kwargs):
super(SendMessageForm, self).__init__(*args, **kwargs)
self.foirequest = foirequest
choices = [(0, _("Default address of %(publicbody)s") % {
"publicbody": foirequest.public_body.name
})]
choices.extend([
(m.id, m.reply_address_entry)
for k, m in foirequest.possible_reply_addresses().items()
])
self.fields['to'].choices = choices
if foirequest.law and foirequest.law.email_only:
self.fields['send_address'] = forms.BooleanField(
label=_("Send physical address"),
help_text=(_(
'If the public body is asking for your post '
'address, check this and we will append it to your message.'
)),
required=False)
class RegistrationForm(forms.Form):
honeypot = forms.CharField(required=False, widget=forms.HiddenInput)
firstname = forms.CharField(label=_('Your first name?'))
lastname = forms.CharField(label=_('Your last name:'))
username = forms.CharField(max_length=30)
password = forms.CharField(
widget=forms.PasswordInput,
help_text=_('Make sure to use a secure password.'),
)
password2 = forms.CharField(label=_('Retype password'), widget=forms.PasswordInput)
age = forms.IntegerField(required=False)
height = forms.DecimalField(localize=True, required=False)
agree_to_terms = forms.BooleanField()
def clean_honeypot(self):
if self.cleaned_data.get('honeypot'):
raise ValidationError('Haha, you trapped into the honeypot.')
return self.cleaned_data['honeypot']
def clean(self):
if self.errors:
raise ValidationError('Please correct the errors below.')
class BaseAddCaseForm(forms.Form):
"""Base form for adding cases."""
product = mtforms.MTModelChoiceField(
model.Product.objects.all(),
choice_attrs=lambda p: {"data-product-id": p.id},
)
productversion = mtforms.MTModelChoiceField(
queryset=model.ProductVersion.objects.all(),
choice_attrs=mtforms.product_id_attrs,
label_from_instance=lambda pv: pv.version,
)
and_later_versions = forms.BooleanField(initial=True, required=False)
def __init__(self, *args, **kwargs):
"""Initialize form; possibly add suite field."""
super(BaseAddCaseForm, self).__init__(*args, **kwargs)
if self.user and self.user.has_perm("library.manage_suite_cases"):
self.fields["suite"] = mtforms.MTModelChoiceField(
model.Suite.objects.all(),
choice_attrs=mtforms.product_id_attrs,
required=False)
def clean(self):
"""Verify that products all match up."""
productversion = self.cleaned_data.get("productversion")
suite = self.cleaned_data.get("suite")
product = self.cleaned_data.get("product")
if product and productversion and productversion.product != product:
raise forms.ValidationError(
"Must select a version of the correct product.")
if product and suite and suite.product != product:
raise forms.ValidationError(
"Must select a suite for the correct product.")
return self.cleaned_data
def __init__(self, user, bt_ids, submit, *args, **kwargs):
super(BankTransactionListForm, self).__init__(*args, **kwargs)
self.fields['tags'].queryset = (
BankTransactionTag.objects.get_user_tags_queryset(user))
self.fields['reconciled'].widget.choices[0] = ('1', _('Reconciled?'))
for pk in bt_ids:
self.fields['banktransaction_' + str(pk)] = forms.BooleanField(
required=False,
widget=forms.CheckboxInput(attrs={'data-id': pk}))
choices = ()
if user.has_perm('banktransactions.change_banktransaction'):
choices += (
('reconcile', _('Reconcile')),
('unreconcile', _('Unreconcile')),
)
if user.has_perm('banktransactions.delete_banktransaction'):
choices += (('delete', _('Delete')), )
if choices:
self.fields['operation'].choices = choices
self._submit = submit
def __init__(self, *args, **kwargs):
super(VirtualMessageFormMixin, self).__init__(*args, **kwargs)
self.fields['is_virtual'] = forms.BooleanField(default=True)
class UserRegistrationForm(ModelFormWithCity, SubscriptionTypeFormMixin):
"""A form for creating a new account on a website"""
email = EmailField(required=True,
label=_("Email"),
widget=forms.TextInput())
password1 = forms.CharField(required=True,
widget=forms.PasswordInput(),
label=_("Password"))
password2 = forms.CharField(required=True,
widget=forms.PasswordInput(),
label=_("Repeat your password"))
entity_type = forms.ChoiceField(required=False, widget=forms.Select())
entity = forms.CharField(
required=False,
widget=forms.TextInput(attrs={'placeholder': _('Name of the entity')}))
groups = forms.MultipleChoiceField(widget=forms.CheckboxSelectMultiple(),
label='',
required=False)
accept_termofuse = forms.BooleanField(
label=_('Accept terms of use'),
help_text=_("Check for accepting the terms of use"))
city = forms.CharField(
required=False,
label=_('City'),
widget=CityAutoComplete(attrs={
'placeholder': _('Enter a city'),
'size': '80'
}))
class Meta:
model = ContactProfile
fields = ('email', 'password1', 'password2', 'entity_type', 'entity',
'gender', 'firstname', 'lastname', 'phone', 'mobile',
'address', 'zip_code', 'city', 'cedex', 'country', 'groups',
'accept_termofuse')
def __init__(self, *args, **kwargs):
super(UserRegistrationForm, self).__init__(*args, **kwargs)
if 'gender' in self.fields:
# do not display Mrs and Mr
self.fields['gender'].choices = [
(Contact.GENDER_NOT_SET, _('Gender')),
(Contact.GENDER_MALE, ugettext('Mr')),
(Contact.GENDER_FEMALE, ugettext('Mrs')),
]
if 'entity_type' in self.fields:
self.fields['entity_type'].choices = [
(0, ugettext('Individual'))
] + [(et.id, et.name)
for et in EntityType.objects.filter(subscribe_form=True)]
if not has_entity_on_registration_form():
self.fields['entity_type'].inital = 0
self.fields['entity_type'].widget = forms.HiddenInput()
self.fields['entity'].widget = forms.HiddenInput()
termsofuse_url = get_registration_accept_terms_of_use_link()
if 'accept_termofuse' in self.fields and termsofuse_url:
self.fields['accept_termofuse'].label = mark_safe(
ugettext('Accept <a href="{0}">terms of use</a>').format(
termsofuse_url))
self._add_subscription_types_field()
def clean_entity(self, ):
entity_type = self.cleaned_data.get('entity_type', None)
entity = self.cleaned_data['entity']
if entity_type:
if not entity:
raise ValidationError(
_("{0}: Please enter a name".format(entity_type)))
return entity
def clean_entity_type(self):
try:
entity_type_id = int(self.cleaned_data['entity_type'] or 0)
except ValueError:
raise ValidationError(ugettext('Invalid entity type'))
if entity_type_id:
try:
return EntityType.objects.get(id=entity_type_id)
except EntityType.DoesNotExist:
raise ValidationError(ugettext('Unknown entity type'))
return None
def clean(self, *args, **kwargs):
password1 = self.cleaned_data.get('password1', "")
password2 = self.cleaned_data.get('password2', "")
if password1 and (password1 != password2):
raise forms.ValidationError(ugettext('Passwords are not the same'))
return super(UserRegistrationForm, self).clean(*args, **kwargs)
def save(self, commit=True):
if get_registration_version() >= "2.0.0":
# Django registration 2.0
# The registration form should return a user
email = self.cleaned_data["email"]
username = email[:30]
user = User.objects.create(username=username,
email=email,
is_active=False)
password = self.cleaned_data.get('password1', "")
user.set_password(password)
return user
else:
# Django registration 1.0
return super(UserRegistrationForm, self).save(commit)
class BankTransactionTagCreateForm(BankTransactionTagForm):
redirect = forms.BooleanField(label=_('Stay on page?'), required=False)
class RequestForm(forms.Form):
public_body = forms.CharField(
widget=PublicBodySelect,
label=_("Search for a topic or a public body:"),
required=False)
subject = forms.CharField(
label=_("Subject"),
max_length=230,
widget=forms.TextInput(attrs={
'placeholder': _("Subject"),
"class": "form-control"
}))
body = forms.CharField(
label=_("Body"),
widget=forms.Textarea(
attrs={
'placeholder': _("Specify your request here..."),
"class": "form-control"
}))
full_text = forms.BooleanField(
required=False,
initial=False,
label=_("Don't wrap in template"),
widget=forms.CheckboxInput(attrs={'tabindex': '-1'}))
public = forms.BooleanField(
required=False,
initial=True,
label=_("This request is public."),
help_text=_(
"If you don't want your request to be public right now,"
" uncheck this. You can always decide to make it public later."))
reference = forms.CharField(widget=forms.HiddenInput, required=False)
redirect_url = forms.CharField(widget=forms.HiddenInput, required=False)
hide_public = forms.BooleanField(widget=forms.HiddenInput,
initial=False,
required=False)
hide_similar = forms.BooleanField(widget=forms.HiddenInput,
initial=False,
required=False)
def __init__(self,
user=None,
list_of_laws=(),
default_law=None,
hide_law_widgets=True,
**kwargs):
super(RequestForm, self).__init__(**kwargs)
self.user = user
self.list_of_laws = list_of_laws
self.indexed_laws = dict([(l.pk, l) for l in self.list_of_laws])
self.default_law = default_law
self.fields["public_body"].widget.set_initial_jurisdiction(
kwargs.get('initial', {}).pop('jurisdiction', None))
self.fields["public_body"].widget.set_initial_search(
kwargs.get('initial', {}).pop('public_body_search', None))
self.fields["law"] = forms.ChoiceField(
label=_("Information Law"),
required=False,
widget=forms.Select if not hide_law_widgets else forms.HiddenInput,
initial=default_law.pk,
choices=((l.pk, l.name) for l in list_of_laws))
def laws_to_json(self):
return json.dumps(
dict([(l.id, l.as_dict()) for l in self.list_of_laws]))
def clean_public_body(self):
pb = self.cleaned_data['public_body']
if pb == "new":
if not new_publicbody_allowed:
raise forms.ValidationError(
_("You are not allowed to create a new public body"))
elif pb == "":
if not publicbody_empty:
raise forms.ValidationError(
_("You must specify a public body"))
pb = None
else:
try:
pb_pk = int(pb)
except ValueError:
raise forms.ValidationError(_("Invalid value"))
try:
public_body = PublicBody.objects.get(pk=pb_pk)
except PublicBody.DoesNotExist:
raise forms.ValidationError(_("Invalid value"))
self.public_body_object = public_body
self.foi_law_object = public_body.default_law
return pb
public_body_object = None
def clean_reference(self):
ref = self.cleaned_data['reference']
if not ref:
return ''
try:
kind, value = ref.split(':', 1)
except ValueError:
return ''
try:
return '%s:%s' % (kind, value)
except ValueError:
return ''
def clean_law_for_public_body(self, public_body):
law = self.clean_law_without_public_body()
if law is None:
return None
if law.jurisdiction.id != public_body.jurisdiction.id:
self._errors["law"] = self.error_class(
[_("Invalid Information Law")])
return None
return law
def clean_law_without_public_body(self):
try:
law = self.cleaned_data['law']
law = self.indexed_laws[int(law)]
except (ValueError, KeyError):
self._errors["law"] = self.error_class(
[_("Invalid Information Law")])
return None
return law
def clean(self):
cleaned = self.cleaned_data
public_body = cleaned.get("public_body")
if public_body is not None and (public_body != "new"
and public_body != ""):
self.foi_law = self.clean_law_for_public_body(
self.public_body_object)
else:
self.foi_law = self.clean_law_without_public_body()
throttle_message = check_throttle(self.user, FoiRequest)
if throttle_message:
raise forms.ValidationError(throttle_message)
return cleaned
class HostingForm(MemoModelForm, CustomDataForm):
providing_housing = forms.BooleanField(initial=False, required=False)
save_as_defaults = forms.BooleanField(
initial=True,
required=False,
label="Remember this information for future events.",
help_text="You will still be able to modify it later.")
class Meta:
model = EventHousing
exclude = ('event', 'home', 'order')
widgets = {'country': forms.Select}
def __init__(self, *args, **kwargs):
super(HostingForm, self).__init__({}, *args, **kwargs)
self.initial.update(
{'providing_housing': self.instance.order.providing_housing})
person = self.instance.order.person
event = self.instance.event
if person is None:
del self.fields['save_as_defaults']
if self.instance.pk is None:
if person is not None:
self.initial.update({
'contact_name': person.get_full_name(),
'contact_email': person.email,
})
home = self.instance.home
if home is not None:
self.initial.update({
'address':
home.address,
'address_2':
home.address_2,
'city':
home.city,
'state_or_province':
home.state_or_province,
'zip_code':
home.zip_code,
'country':
home.country,
'public_transit_access':
home.public_transit_access,
'ef_present':
self.filter(EnvironmentalFactor.objects.only('id'),
home_present=home),
'ef_avoid':
self.filter(EnvironmentalFactor.objects.only('id'),
home_avoid=home),
'person_prefer':
home.person_prefer,
'person_avoid':
home.person_avoid,
'housing_categories':
self.filter(HousingCategory.objects.only('id'),
homes=home),
})
else:
self.initial.update({
'city': event.city,
'state_or_province': event.state_or_province,
'country': event.country,
})
self.set_choices('ef_present',
EnvironmentalFactor.objects.only('id', 'name'))
self.set_choices('ef_avoid',
EnvironmentalFactor.objects.only('id', 'name'))
self.set_choices('housing_categories',
HousingCategory.objects.only('id', 'name'))
self.nights = self.filter(HousingRequestNight,
date__gte=event.start_date -
datetime.timedelta(1),
date__lte=event.end_date)
slot_map = {}
if self.instance.pk is not None:
slot_map = {
slot.date: slot
for slot in self.filter(HousingSlot,
eventhousing=self.instance)
}
data = None if not self.is_bound else self.data
self.slot_forms = []
for night in self.nights:
if night.date in slot_map:
instance = slot_map[night.date]
else:
instance = HousingSlot(eventhousing=self.instance,
date=night.date)
self.slot_forms.append(
HousingSlotForm(instance=instance,
data=data,
prefix='{}-{}'.format(self.prefix, night.pk)))
def get_custom_forms(self):
return self.instance.event.forms.filter(
form_type=CustomForm.HOSTING).prefetch_related('fields')
def clean(self):
cleaned_data = super(HostingForm, self).clean()
if 'country' in cleaned_data and 'zip_code' in cleaned_data:
country = cleaned_data['country']
code = cleaned_data['zip_code']
try:
cleaned_data['zip_code'] = clean_postal_code(country, code)
except ValidationError, e:
del cleaned_data['zip_code']
self.add_error('zip_code', e)
return cleaned_data
class RunForm(mtforms.NonFieldErrorsClassFormMixin, mtforms.MTModelForm):
"""Base form for adding/editing runs."""
suites = mtforms.MTMultipleChoiceField(
required=False,
widget=mtforms.FilteredSelectMultiple(
choice_template="manage/run/suite_select/_suite_select_item.html",
listordering_template=(
"manage/run/suite_select/_suite_select_listordering.html"),
filters=[
filters.KeywordFilter("name"),
filters.ModelFilter(
"author", queryset=model.User.objects.all()),
],
)
)
productversion = mtforms.MTModelChoiceField(
queryset=model.ProductVersion.objects.all(),
choice_attrs=mtforms.product_id_attrs,
)
build = forms.CharField(max_length=200, required=False)
is_series = forms.BooleanField(required=False)
class Meta:
model = model.Run
fields = [
"productversion",
"name",
"description",
"is_series",
"build",
"start",
"end",
"is_series",
]
widgets = {
"name": forms.TextInput,
"description": mtforms.BareTextarea,
"build": forms.TextInput,
"is_series": forms.CheckboxInput,
"start": forms.DateInput,
"end": forms.DateInput,
}
def clean_suites(self):
"""
Make sure all the ids for the suites are valid and populate
self.cleaned_data with the real objects.
If these are not ids, then they are read-only strings of the title
and therefore don't need to be validated. So first verify they're
all ints.
"""
try:
suites = dict((unicode(x.id), x) for x in
model.Suite.objects.filter(pk__in=self.cleaned_data["suites"]))
try:
return [suites[x] for x in self.cleaned_data["suites"]]
except KeyError as e:
raise ValidationError("Not a valid suite for this run.")
except ValueError:
# some of the values weren't ints, and therefore this is
# from the read-only list of suites. so return None so that we
# don't try to remove and re-add them.
if "suites" in self.changed_data: # pragma: no cover
self.changed_data.remove("suites")
return None
def clean_build(self):
"""If this is a series, then null out the build field."""
if self.cleaned_data["is_series"]:
return None
def save(self, user=None):
"""Save and return run, with suite associations."""
user = user or self.user
run = super(RunForm, self).save(user=user)
if "suites" in self.changed_data:
# if this is empty, then don't make any changes, because
# either there are no suites, or this came from the read
# only suite list.
run.runsuites.all().delete(permanent=True)
for i, suite in enumerate(self.cleaned_data["suites"]):
model.RunSuite.objects.create(
run=run, suite=suite, order=i, user=user)
return run
def __init__(self, *args, **kwargs):
# Configure the fieldset with dynamic fields
fieldset_fields = self.Meta.fieldsets[-2][1]["fields"]
for subscription_type in models.SubscriptionType.objects.all():
field_name = "subscription_{0}".format(subscription_type.id)
if field_name not in fieldset_fields:
fieldset_fields.append(field_name)
has_data = len(args) > 0
super(ContactForm, self).__init__(*args, **kwargs)
try:
if self.instance and self.instance.entity and self.instance.entity.is_single_contact:
self.fields['has_left'].widget = forms.HiddenInput()
except models.Entity.DoesNotExist:
pass
self.fields["role"].help_text = _(
"Select the roles played by the contact in his entity")
if 'balafon.Profile' not in settings.INSTALLED_APPS:
self.fields["accept_notifications"].widget = forms.HiddenInput()
if has_data:
self.fields.pop("email_verified")
else:
self.fields["email_verified"].widget.attrs['disabled'] = "disabled"
# define the allowed gender
gender_choices = [
(models.Contact.GENDER_NOT_SET, '-------'),
(models.Contact.GENDER_MALE, ugettext('Mr')),
(models.Contact.GENDER_FEMALE, ugettext('Mrs')),
]
if ALLOW_COUPLE_GENDER:
gender_choices += [(models.Contact.GENDER_COUPLE,
ugettext('Mrs and Mr'))]
self.fields['gender'].choices = gender_choices
# create the dynamic fields
for subscription_type in models.SubscriptionType.objects.all():
field_name = "subscription_{0}".format(subscription_type.id)
field = self.fields[field_name] = forms.BooleanField(
label=subscription_type.name, required=False)
if self.instance and self.instance.id:
try:
subscription = models.Subscription.objects.get(
subscription_type=subscription_type,
contact=self.instance)
field.initial = subscription.accept_subscription
except models.Subscription.DoesNotExist:
field.initial = False
else:
field.initial = get_subscription_default_value()
if has_language_choices():
self.fields['favorite_language'].widget = forms.Select(
choices=get_language_choices(),
attrs={'class': 'form-control'})
else:
self.fields['favorite_language'].widget = forms.HiddenInput()
if not self.instance or not any([
self.instance.lastname, self.instance.firstname,
self.instance.email
]):
# If the contact has not been created of not filled
pass
# keep the widget
if len(args):
# The form has been posted; we must initialize the list with allowed values
contact_id = self.instance.id if self.instance else None
post_data = args[0]
lastname = post_data.get('lastname', '')
firstname = post_data.get('firstname', '')
email = post_data.get('email', '')
same_as_contacts = get_suggested_same_as_contacts(
contact_id=contact_id,
lastname=lastname,
firstname=firstname,
email=email)
self.fields['same_as_suggestions'].choices = [
(contact.id, '{0}'.format(contact))
for contact in same_as_contacts
]
else:
# hide the field
self.fields['same_as_suggestions'].widget = forms.HiddenInput()
class EventCreateForm(forms.ModelForm):
template_event = forms.ModelChoiceField(queryset=Event.objects.all(),
required=False)
new_organization_name = forms.CharField(required=False)
new_organization_slug = forms.SlugField(required=False)
create_new_organization = forms.BooleanField(required=False)
organization = forms.ModelChoiceField(queryset=Organization.objects.all(),
required=False)
class Meta:
model = Event
fields = ('name', 'slug', 'start_date', 'end_date', 'start_time',
'end_time')
def __init__(self, request, *args, **kwargs):
super(EventCreateForm, self).__init__(*args, **kwargs)
self.request = request
if not request.user.is_authenticated():
raise ValueError("EventCreateForm requires an authenticated user.")
self.fields['template_event'].queryset = Event.objects.filter(
Q(organization__members=request.user)
| Q(members=request.user)).order_by('-last_modified').distinct()
self.fields['organization'].queryset = Organization.objects.filter(
organizationmember__person=request.user,
organizationmember__role__in=(
OrganizationMember.OWNER,
OrganizationMember.EDIT,
)).order_by('name').distinct()
self.initial['create_new_organization'] = not self.fields[
'organization'].queryset
def clean(self):
cd = super(EventCreateForm, self).clean()
if ('start_date' in cd and 'end_date' in cd
and cd['start_date'] > cd['end_date']):
self.add_error(
'start_date',
"Start date must be before or equal to the end date.")
if (cd.get('template_event') and cd.get('organization') and
cd['template_event'].organization_id != cd['organization'].id):
self.add_error(
'template_event',
"Template event and new event must be from the same organization."
)
if cd.get('create_new_organization'):
if cd.get('new_organization_slug'):
if Organization.objects.filter(
slug=cd['new_organization_slug']).exists():
self.add_error(
'new_organization_slug',
'URL is already in use by another organization; please choose a different one.'
)
else:
self.add_error('new_organization_slug',
'New organization requires a URL.')
if not cd.get('new_organization_name'):
self.add_error('new_organization_name',
'New organization requires a URL.')
else:
if not cd.get('organization'):
self.add_error('organization', 'Organization is required.')
elif cd.get('slug'):
if Event.objects.filter(organization=cd['organization'],
slug=cd['slug']).exists():
self.add_error(
'slug',
'URL is already in use by another event; please choose a different one.'
)
return cd
def _adjust_date(self, old_event, new_event, date):
"""
Returns a date relative to the new event's start date as the given date
is relative to the olde event's start date.
"""
return date + (new_event.start_date - old_event.start_date)
def save(self):
if self.cleaned_data.get('create_new_organization'):
self.instance.organization = Organization.objects.create(
name=self.cleaned_data['new_organization_name'],
slug=self.cleaned_data['new_organization_slug'],
)
OrganizationMember.objects.create(
organization=self.instance.organization,
person=self.request.user,
role=OrganizationMember.OWNER,
)
else:
self.instance.organization = self.cleaned_data['organization']
if self.instance.is_demo():
self.instance.api_type = Event.TEST
self.instance.application_fee_percent = self.instance.organization.default_application_fee_percent
template = self.cleaned_data.get('template_event')
if template:
fields = (
'description',
'website_url',
'banner_image',
'city',
'state_or_province',
'country',
'timezone',
'currency',
'has_dances',
'has_classes',
'liability_waiver',
'privacy',
'collect_housing_data',
'collect_survey_data',
'cart_timeout',
'check_postmark_cutoff',
'transfers_allowed',
'facebook_url',
)
for field in fields:
setattr(self.instance, field, getattr(template, field))
instance = super(EventCreateForm, self).save()
if template:
items = Item.objects.filter(event=template).prefetch_related(
'options', 'images')
for item in items:
options = list(item.options.all())
images = list(item.images.all())
item.pk = None
item.event = instance
item.save()
for option in options:
option.pk = None
option.item = item
option.available_start = self._adjust_date(
template, instance, option.available_start)
option.available_end = self._adjust_date(
template, instance, option.available_end)
ItemOption.objects.bulk_create(options)
for image in images:
image.pk = None
image.item = item
ItemImage.objects.bulk_create(images)
discounts = list(Discount.objects.filter(event=template))
for discount in discounts:
discount.pk = None
discount.event = instance
discount.available_start = self._adjust_date(
template, instance, discount.available_start)
discount.available_end = self._adjust_date(
template, instance, discount.available_end)
Discount.objects.bulk_create(discounts)
saved_reports = list(SavedReport.objects.filter(event=template))
for saved_report in saved_reports:
saved_report.pk = None
saved_report.event = instance
SavedReport.objects.bulk_create(saved_reports)
forms = CustomForm.objects.filter(
event=template).prefetch_related('fields')
for form in forms:
fields = list(form.fields.all())
form.pk = None
form.event = instance
form.save()
for field in fields:
field.pk = None
field.form = form
CustomFormField.objects.bulk_create(fields)
return instance
