class SameAsForm(forms.Form):
"""Define "same as" for two contacts"""
contact = forms.IntegerField(label=_("Contact"))
def __init__(self, contact, *args, **kwargs):
super(SameAsForm, self).__init__(*args, **kwargs)
potential_contacts = get_suggested_same_as_contacts(
contact_id=contact.id,
lastname=contact.lastname,
firstname=contact.firstname,
email=contact.email)
if contact.same_as:
# Do not propose again current SameAs
potential_contacts = potential_contacts.exclude(
same_as=contact.same_as)
self._same_as = [(same_as_contact.id, "{0}".format(same_as_contact))
for same_as_contact in potential_contacts]
if len(self._same_as):
self.fields["contact"].widget = forms.Select(choices=self._same_as)
else:
self.fields["contact"].widget = forms.HiddenInput()
def has_choices(self):
"""true if several contacts with same name"""
return len(self._same_as)
def clean_contact(self):
"""validation"""
contact_id = self.cleaned_data["contact"]
try:
if contact_id not in [same_as[0] for same_as in self._same_as]:
raise ValidationError(ugettext("Invalid contact"))
return models.Contact.objects.get(id=contact_id)
except models.Contact.DoesNotExist:
raise ValidationError(ugettext("Contact does not exist"))
class UserEmailConfirmationForm(forms.Form):
email = forms.EmailField()
secret = forms.CharField(min_length=32, max_length=32)
user_id = forms.IntegerField()
def __init__(self, user, *args, **kwargs):
self.user = user
super(UserEmailConfirmationForm, self).__init__(*args, **kwargs)
def clean_user_id(self):
user_id = self.cleaned_data['user_id']
if user_id != self.user.pk:
raise forms.ValidationError(
_('Logged in user does not match this link!'))
return user_id
def clean(self):
check = AccountManager(self.user).check_confirmation_secret(
self.cleaned_data['secret'],
self.cleaned_data['email'],
)
if not check:
raise forms.ValidationError(_('Link is invalid or has expired!'))
return self.cleaned_data
def save(self):
self.user.email = self.cleaned_data['email']
self.user.save()
class ThreadForm(MessageForm):
""" Formulaire de fil de discussion """
# Constantes
SUBJECT_LENGTH_MIN = 1
# Champs supplémentaires
subject = forms.CharField(max_length=48,
required=False,
widget=forms.TextInput())
recipient = forms.IntegerField(required=True, widget=forms.HiddenInput())
# Validation
def clean_subject(self):
""" Valider et renvoyer les données du champ sujet """
subject = self.data['subject']
if len(subject) < ThreadForm.SUBJECT_LENGTH_MIN:
raise forms.ValidationError(
_("Your subject must be at least {} characters long.").format(
ThreadForm.SUBJECT_LENGTH_MIN))
return subject
def clean_recipient(self):
""" Valider et renvoyer les données du champ destinataire """
recipient = int(self.data['recipient'])
if get_user_model().objects.get_or_none(id=recipient) is None:
raise forms.ValidationError(_("The recipient does not exist."))
return get_user_model().objects.get(id=recipient)
class EditCaseVersionForm(mtforms.SaveIfValidMixin,
BaseCaseVersionForm,
BaseCaseForm,
):
"""Form for editing a case version."""
cc_version = forms.IntegerField(widget=forms.HiddenInput)
def __init__(self, *args, **kwargs):
"""Initialize EditCaseVersionForm, pulling instance from kwargs."""
self.instance = kwargs.pop("instance", None)
initial = kwargs.setdefault("initial", {})
initial["name"] = self.instance.name
initial["description"] = self.instance.description
initial["status"] = self.instance.status
initial["cc_version"] = self.instance.cc_version
initial["idprefix"] = self.instance.case.idprefix
initial["priority"] = self.instance.case.priority
super(EditCaseVersionForm, self).__init__(*args, **kwargs)
def save(self, user=None):
"""Save the edited caseversion."""
user = user or self.user
assert self.is_valid()
version_kwargs = self.cleaned_data.copy()
del version_kwargs["add_tags"]
del version_kwargs["add_attachment"]
idprefix = version_kwargs.pop("idprefix")
priority = version_kwargs.pop("priority")
for k, v in version_kwargs.items():
setattr(self.instance, k, v)
if self.instance.case.idprefix != idprefix:
self.instance.case.idprefix = idprefix
self.instance.case.save(force_update=True)
if self.instance.case.priority != priority:
try:
int(priority)
except ValueError:
priority = None
self.instance.case.priority = priority
self.instance.case.save(force_update=True)
self.instance.save(force_update=True)
self.save_new_tags(self.instance.case.product)
self.save_tags(self.instance)
self.save_attachments(self.instance)
self.steps_formset.save(user=user)
return self.instance
def __init__(self, *args, **kwargs):
super(SRForm, self).__init__(*args, **kwargs)
curmax = int(kwargs['instance'].sender.participant.vars['herd_size'])
self.fields['amount_sent'] = forms.IntegerField(label='How many cattle will you send this player?',
required=True,
max_value=curmax,
min_value=0,
)
class UpdateFavoriteForm(forms.Form):
object_id = forms.IntegerField(required=True)
content_type = ContentTypeField(required=True)
def __init__(self, *args, **kwargs):
instance = kwargs.pop('instance', None)
if instance:
kwargs['initial'] = {
'object_id': instance.id,
'content_type': ContentType.objects.get_for_model(instance.__class__).id,
}
super(UpdateFavoriteForm, self).__init__(*args, **kwargs)
def __init__(self, *args, **kwargs):
choices = kwargs.pop('choices', None)
super(SelectContactForm, self).__init__(*args, **kwargs)
if choices:
widget = forms.Select(choices=[(x.id, x.fullname)
for x in choices])
self.fields["contact"] = forms.IntegerField(label=_("Contact"),
widget=widget)
else:
widget = ContactAutoComplete(
attrs={
'placeholder': _('Enter the name of a contact'),
'size': '50',
'class': 'colorbox'
})
self.fields["contact"] = forms.CharField(label=_("Contact"),
widget=widget)
class SameAsPriorityForm(BetterBsForm):
"""Define "same as" priority for a contact"""
priority = forms.IntegerField(label=_("Priority"))
def __init__(self, contact, *args, **kwargs):
super(SameAsPriorityForm, self).__init__(*args, **kwargs)
self.contact = contact
self.fields['priority'].initial = contact.same_as_priority
def clean_priority(self):
"""make sure that the priority is an integer between 1 and number of same as"""
value = self.cleaned_data['priority']
min_value = 1
max_value = self.contact.same_as.contact_set.count()
if value < min_value or value > max_value:
raise ValidationError(
ugettext(
'Invalid value : It should be between {0} and {1}').format(
min_value, max_value))
return value
class SameAsSuggestionForm(forms.Form):
"""
generate suggestion list from a few data.
This form is not displayed and used by json API
"""
id = forms.IntegerField(required=False)
lastname = forms.CharField(required=False)
firstname = forms.CharField(required=False)
email = forms.CharField(required=False)
def get_suggested_contacts(self):
"""return list a suggestions for same as"""
contact_id = self.cleaned_data['id']
lastname = self.cleaned_data['lastname']
firstname = self.cleaned_data['firstname']
email = self.cleaned_data['email']
return get_suggested_same_as_contacts(contact_id=contact_id,
lastname=lastname,
firstname=firstname,
email=email)
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.')
def __init__(self, request=None, *args, **kwargs):
"""Initialize form, including captcha question and expected answer."""
super(CaptchaAuthenticationForm, self).__init__(*args, **kwargs)
# get previous expected answer before generating new one
self.captcha_answer = request.session.get(CAPTCHA_SESSION_KEY)
# only add the captcha field if this request hit the rate limit
if getattr(request, "limited", False):
a, b = random.randint(1, 9), random.randint(1, 9)
# avoid negative answers
if b > a:
a, b = b, a
opname, op = random.choice(OPERATORS.items())
# store the expected answer in the session
request.session[CAPTCHA_SESSION_KEY] = op(a, b)
self.fields["captcha"] = forms.IntegerField(
widget=forms.TextInput,
required=False,
label=u"What is {0} {1} {2}?".format(a, opname, b),
)
class SearchNameForm(forms.Form):
"""Save search form"""
search_id = forms.IntegerField(required=False, widget=forms.HiddenInput())
name = forms.CharField(required=True, label=_("Name"))
search_fields = forms.CharField(required=True, widget=forms.HiddenInput())
def clean_name(self):
"""validate name"""
search_id = self.cleaned_data["search_id"]
name = self.cleaned_data["name"]
if not name:
raise ValidationError(_("This field is required"))
queryset = models.Search.objects.filter(name=name)
if search_id:
queryset = queryset.exclude(id=search_id)
if queryset.count() > 0:
raise ValidationError(_("This name is already used"))
if search_id:
search = models.Search.objects.get(id=search_id)
if search.name != name:
search.name = name
search.save()
else:
search = models.Search(name=name)
return search
def clean_search_fields(self):
"""validate search fields"""
search_fields = self.cleaned_data["search_fields"]
data = json.loads(search_fields)
for key in ('csrfmiddlewaretoken', 'excluded', 'name', 'field_choice'):
data.pop(key, None)
return data
class BasicForm(forms.Form):
"""
TODO:--------------------------
input TextInput OK
inputN NumberInput OK
inputEmail EmailInput
textarea TextInput OK
drowpdown Select OK
drowpdown SelectMultiple OK
checkbox CheckboxInput
checkbox2 MultiCheckbox?
radiobox RadioSelect
date DateInput
time TimeInput
datetime DateTimeInput
"""
COLORS_CHOICES = [
('blue', 'Blue'),
('green', 'Green'),
('black', 'Black'),
]
name = forms.CharField(max_length=32, widget=widgets.TextInput())
year = forms.IntegerField(widget=widgets.NumberInput())
description = forms.CharField(max_length=32, widget=widgets.Textarea(attrs={'rows': '4'}))
color = forms.ChoiceField(widget=widgets.Select(), choices=COLORS_CHOICES)
colors = forms.MultipleChoiceField(widget=widgets.Select(attrs={'multiple': True}), choices=COLORS_CHOICES)
is_boolean = forms.CharField(max_length=32, widget=widgets.CheckboxInput())
option = forms.ChoiceField(widget=widgets.RadioSelect(), choices=COLORS_CHOICES)
is_not_boolean = forms.CharField(max_length=32, widget=widgets.CheckboxInput())
option_again = forms.CharField(max_length=32, widget=widgets.CheckboxInput())
def __init__(self, *args, **kwargs):
super(BasicForm, self).__init__(*args, **kwargs)
self.fields["year"].initial = 2021
class SelectContactOrEntityForm(forms.Form):
"""Select a contact or entity"""
object_id = forms.IntegerField(widget=forms.HiddenInput(), required=True)
object_type = forms.CharField(widget=forms.HiddenInput(), required=True)
name = forms.CharField(required=True, label=_('Name'))
def clean_name(self):
"""validation"""
object_id = self.cleaned_data.get('object_id', '')
object_type = self.cleaned_data.get('object_type', '')
object_class = {
'contact': models.Contact,
'entity': models.Entity,
}.get(object_type, None)
if not object_class:
raise ValidationError(
ugettext("Invalid type '{0}'").format(object_type))
try:
object_id = int(object_id)
return object_class.objects.get(id=object_id)
except (ValueError, object_class.DoesNotExist):
raise ValidationError(ugettext("Does'nt exist"))
class ChangeContactEntityForm(forms.Form):
"""Switch contact entity form"""
OPTION_ADD_TO_EXISTING_ENTITY = 1
OPTION_CREATE_NEW_ENTITY = 2
OPTION_SWITCH_SINGLE_CONTACT = 3
OPTION_SWITCH_ENTITY_CONTACT = 4
OPTION_CHOICES = (
(0, ""),
(OPTION_ADD_TO_EXISTING_ENTITY, _("Reassign to an existing entity")),
(OPTION_CREATE_NEW_ENTITY, _("Create a new entity")),
(OPTION_SWITCH_SINGLE_CONTACT, _("Switch to single contact")),
(OPTION_SWITCH_ENTITY_CONTACT, _("Switch to entity contact")),
)
option = forms.ChoiceField(label=_("What to do?"))
entity = forms.IntegerField(
label=_("Which one?"),
required=False,
widget=EntityAutoComplete(
attrs={
'placeholder': _('Enter the name of the entity'),
'size': '50',
'class': 'colorbox'
}))
def __init__(self, contact, *args, **kwargs):
self.contact = contact
super(ChangeContactEntityForm, self).__init__(*args, **kwargs)
if contact.entity.is_single_contact:
single_contact_choices = (self.OPTION_CREATE_NEW_ENTITY,
self.OPTION_SWITCH_SINGLE_CONTACT)
choices = [
choice for choice in self.OPTION_CHOICES
if choice[0] not in single_contact_choices
]
else:
choices = [
choice for choice in self.OPTION_CHOICES
if choice[0] != self.OPTION_SWITCH_ENTITY_CONTACT
]
self.fields['option'].choices = choices
self.meth_map = {
self.OPTION_ADD_TO_EXISTING_ENTITY: self._add_to_existing_entity,
self.OPTION_CREATE_NEW_ENTITY: self._create_new_entity,
self.OPTION_SWITCH_SINGLE_CONTACT: self._switch_single_contact,
self.OPTION_SWITCH_ENTITY_CONTACT: self._switch_entity_contact,
}
def clean_option(self):
"""validation"""
try:
option = int(self.cleaned_data["option"])
if option == 0:
raise ValidationError(
ugettext("Please select one of this options"))
try:
self.meth_map[option]
except KeyError:
raise ValidationError(ugettext("Invalid value"))
except ValueError:
raise ValidationError(ugettext("Invalid data"))
return option
def clean_entity(self):
"""validation"""
option = self.cleaned_data.get("option", 0)
if option != self.OPTION_ADD_TO_EXISTING_ENTITY:
return None
else:
entity_id = self.cleaned_data["entity"]
try:
return models.Entity.objects.get(id=entity_id)
except models.Entity.DoesNotExist:
raise ValidationError(
ugettext("Please select an existing entity"))
def _add_to_existing_entity(self):
"""add to exsiting entity"""
old_entity = self.contact.entity
self.contact.entity = self.cleaned_data["entity"]
self.contact.save()
old_entity.save()
def _create_new_entity(self):
"""create new entity"""
old_entity = self.contact.entity
self.contact.entity = models.Entity.objects.create()
self.contact.save()
old_entity.save()
def _switch_single_contact(self):
"""switch to single contact"""
old_entity = self.contact.entity
self.contact.entity = models.Entity.objects.create(
is_single_contact=True,
name="{0.lastname} {0.firstname}".format(self.contact).lower())
self.contact.save()
self.contact.entity.default_contact.delete()
self.contact.entity.save()
old_entity.save()
def _switch_entity_contact(self):
"""switch to entity"""
self.contact.entity.is_single_contact = False
self.contact.entity.save()
def change_entity(self):
"""change entity: call the method corresponding to the choice"""
option = self.cleaned_data["option"]
method = self.meth_map[option]
method()
class AddRelationshipForm(forms.Form):
"""form for adding relationships"""
relationship_type = forms.IntegerField(label=_("relationship type"))
contact2 = forms.CharField(label=_("Contact"))
def __init__(self, contact1, *args, **kwargs):
super(AddRelationshipForm, self).__init__(*args, **kwargs)
self.reversed_relation = False
self.contact1 = contact1
relationship_types = []
for relationship_type in models.RelationshipType.objects.all():
relationship_types.append(
(relationship_type.id, relationship_type.name))
if relationship_type.reverse:
relationship_types.append(
(-relationship_type.id, relationship_type.reverse))
self.fields["relationship_type"].widget = forms.Select(
choices=relationship_types)
widget = ContactAutoComplete(
attrs={
'placeholder': _('Enter the name of a contact'),
'size': '50',
'class': 'colorbox'
})
self.fields["contact2"] = forms.CharField(label=_("Contact"),
widget=widget)
def clean_relationship_type(self):
"""validate relationship type"""
try:
self.reversed_relation = False
relationship_type = int(self.cleaned_data["relationship_type"])
if relationship_type < 0:
self.reversed_relation = True
relationship_type = -relationship_type
return models.RelationshipType.objects.get(id=relationship_type)
except ValueError:
raise ValidationError(ugettext("Invalid data"))
except models.RelationshipType.DoesNotExist:
raise ValidationError(ugettext("Relationship type does not exist"))
def clean_contact2(self):
"""clean the contacts in relation"""
try:
contact2 = int(self.cleaned_data["contact2"])
return models.Contact.objects.get(id=contact2)
except ValueError:
raise ValidationError(ugettext("Invalid data"))
except models.Contact.DoesNotExist:
raise ValidationError(ugettext("Contact does not exist"))
def save(self):
"""save"""
if self.reversed_relation:
contact1 = self.cleaned_data["contact2"]
contact2 = self.contact1
else:
contact1 = self.contact1
contact2 = self.cleaned_data["contact2"]
relationship_type = self.cleaned_data["relationship_type"]
return models.Relationship.objects.create(
contact1=contact1,
contact2=contact2,
relationship_type=relationship_type)
def test_parse_int(self):
int_field = forms.IntegerField()
result = int_field.clean('15')
self.assertEqual(15, result)
self.assertIsInstance(result, int)
class IntForm(DjangoForm):
num = forms.IntegerField(max_value=10)
other = forms.IntegerField()
third = forms.IntegerField(min_value=10, max_value=150)
class FoiRequestStatusForm(forms.Form):
def __init__(self, foirequest, *args, **kwargs):
super(FoiRequestStatusForm, self).__init__(*args, **kwargs)
self.foirequest = foirequest
self.fields['refusal_reason'] = forms.ChoiceField(
label=_("Refusal Reason"),
choices=[('', _('No or other reason given'))] +
(foirequest.law.get_refusal_reason_choices()),
required=False,
widget=forms.Select(attrs={'class': 'form-control'}),
help_text=
_('When you are (partially) denied access to information, the Public Body should always state the reason.'
))
status = forms.ChoiceField(
label=_("Status"),
widget=forms.RadioSelect,
choices=[
('awaiting_response', _('This request is still ongoing.')),
('resolved', _('This request is finished.')),
# ('request_redirected', _('This request has been redirected to a different public body.'))
])
resolution = forms.ChoiceField(
label=_('Resolution'),
choices=[('', _('No outcome yet'))] +
FoiRequest.RESOLUTION_FIELD_CHOICES,
required=False,
widget=forms.Select(attrs={'class': 'form-control'}),
help_text=_(
'How would you describe the current outcome of this request?'))
redirected = forms.IntegerField(
label=_("Redirected to"),
required=False,
widget=PublicBodySelect,
help_text=
_('If your message is redirected to a different Public Body, please specify the new Public Body'
))
if payment_possible:
costs = forms.FloatField(
label=_("Costs"),
required=False,
min_value=0.0,
localize=True,
widget=PriceInput,
help_text=
_('Please specify what the Public Body charges for the information.'
))
def clean_costs(self):
costs = self.cleaned_data['costs']
if costs is None:
return 0.0
return costs
def clean(self):
pk = self.cleaned_data.get('redirected', None)
status = self.cleaned_data.get('status', None)
if status == "request_redirected":
if pk is None:
raise forms.ValidationError(
_("Provide the redirected public body!"))
try:
self._redirected_public_body = PublicBody.objects.get(id=pk)
except PublicBody.DoesNotExist:
raise forms.ValidationError(_("Invalid value"))
if status == 'resolved':
if not self.cleaned_data.get('resolution', ''):
raise forms.ValidationError(
_('Please give a resolution to this request'))
# if resolution is successful or partially_successful, set status to resolved
if self.cleaned_data.get('resolution',
'') in ('successful', 'partially_successful'):
self.cleaned_data['status'] = 'resolved'
return self.cleaned_data
def set_status(self):
data = self.cleaned_data
status = data['status']
resolution = data['resolution']
foirequest = self.foirequest
message = foirequest.message_needs_status()
if message:
message.status = status
message.save()
if status == "request_redirected":
foirequest.due_date = foirequest.law.calculate_due_date()
foirequest.public_body = self._redirected_public_body
status = 'awaiting_response'
foirequest.status = status
foirequest.resolution = resolution
foirequest.costs = data['costs']
if resolution == "refused" or resolution == "partially_successful":
foirequest.refusal_reason = data['refusal_reason']
else:
foirequest.refusal_reason = u""
foirequest.save()
status = data.pop("status")
if status == 'resolved':
foirequest.status_changed.send(sender=foirequest,
status=resolution,
data=data)
class NewEmailingForm(BsForm):
"""Form for creating a new emailing"""
subscription_type = forms.IntegerField(label=_("Subscription Type"))
newsletter = forms.IntegerField(label=_("Newsletter"))
subject = forms.CharField(
label=_("Subject"),
required=False,
widget=forms.TextInput(
attrs={'placeholder': _('Subject of the newsletter')}))
contacts = forms.CharField(widget=forms.HiddenInput())
lang = forms.CharField(required=False,
label=_("Language"),
widget=forms.Select(choices=[('', _('Default'))] +
list(settings.LANGUAGES)))
from_email = forms.CharField(required=False, label=_("Sent from"))
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(NewEmailingForm, self).__init__(*args, **kwargs)
if initial_contacts:
self.fields['contacts'].initial = initial_contacts
newsletter_choices = [(0, ugettext('-- New --'))] + [
(newsletter.id, newsletter.subject)
for newsletter in Newsletter.objects.all().order_by('-id')
]
self.fields["newsletter"].widget = forms.Select(
choices=newsletter_choices, attrs={'class': 'form-control'})
subscription_choices = [
(subscription.id, subscription.name)
for subscription in SubscriptionType.objects.all()
]
self.fields["subscription_type"].widget = forms.Select(
choices=subscription_choices, attrs={'class': 'form-control'})
if not getattr(settings, 'LANGUAGES',
None) or len(settings.LANGUAGES) < 2:
self.fields["lang"].widget = forms.HiddenInput()
else:
language_choices = crm_settings.get_language_choices(
_("Favorite language of the contact"))
self.fields["lang"].widget = forms.Select(
choices=language_choices, attrs={'class': 'form-control'})
if getattr(settings, 'BALAFON_EMAILING_SENDER_CHOICES', None):
self.fields['from_email'].widget = forms.Select(
choices=settings.BALAFON_EMAILING_SENDER_CHOICES,
attrs={'class': 'form-control'})
else:
self.fields['from_email'].widget = forms.HiddenInput()
def get_contacts(self):
"""get the list of contacts stored by ids"""
ids = self.cleaned_data["contacts"].split(";")
return models.Contact.objects.filter(id__in=ids)
def clean_subject(self):
"""subject validation"""
newsletter_id = int(self.cleaned_data['newsletter'])
subject = self.cleaned_data['subject']
if newsletter_id == 0 and not subject:
raise ValidationError(
ugettext("Please enter a subject for the newsletter"))
return subject
def clean_subscription_type(self):
"""validation of subscription type. Return the subscription type object"""
try:
subscription_type = int(self.cleaned_data['subscription_type'])
return SubscriptionType.objects.get(id=subscription_type)
except (ValueError, KeyError, SubscriptionType.DoesNotExist):
raise ValidationError(
ugettext("Please select a valid subscription"))
