class SymptonsForm(forms.ModelForm):
temperature = forms.FloatField(min_value=36,
max_value=45,
help_text='Temperatura corporal',
label='Temperatura',
initial=36.5)
edad = forms.IntegerField(help_text='Edad actual',
label='Edad',
initial=False,
required=True,
min_value=1,
max_value=120)
sexo = forms.ChoiceField(help_text='Género',
label='Género',
initial=False,
required=False,
choices=((1, ''), (2, 'Hombre'), (3, 'Mujer')))
tos = forms.BooleanField(help_text='¿Tienes tos?',
label='Tos',
initial=False,
required=False)
dolor_cabeza = forms.BooleanField(help_text='¿Tienes dolor de cabeza?',
label='Dolor de Cabeza',
initial=False,
required=False)
dolor_garganta = forms.BooleanField(help_text='¿Tienes dolor de garganta?',
label='Dolor de garganta',
initial=False,
required=False)
respiracion = forms.BooleanField(
help_text='¿Tienes dificultad para respirar?',
label='Dificultad para Respirar',
initial=False,
required=False)
latitude = forms.FloatField(initial=20, label='Latitud',
required=False) #, disabled='disabled')
longitude = forms.FloatField(initial=-105,
label='Longitud',
required=False) #, disabled='disabled')
# location = SpatialLocationField()
class Meta:
model = Person
fields = [
'temperature',
'latitude',
'longitude',
'age',
'sexo',
]
class SearchForm(forms.Form):
postcode = forms.CharField(max_length=50,
required=False,
help_text="Enter a Post code to search from")
use_current_location = forms.BooleanField(initial=False, required=False)
search_radius = forms.IntegerField(min_value=0,
max_value=200,
help_text="Search distance (Miles)")
maximum_length = forms.IntegerField(
required=False,
min_value=0,
max_value=250,
help_text="Maximum walk length (Miles)",
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for attribute in Attribute.objects.all():
self.fields[attribute.attribute] = forms.BooleanField(
initial=False, required=False)
def clean(self):
if (not self.cleaned_data["postcode"]
and not self.cleaned_data["use_current_location"]):
raise forms.ValidationError(
"You must enter a postcode or location or use your current location"
)
class ProjectForm(forms.ModelForm):
european_network = forms.BooleanField(
label=
u"Etre visible sur le réseau européen des villes et territoires durables (<a target='_blank' href='http://rfsc.eu/fr/'>RFSC</a>)",
required=False,
help_text=
u"En cochant cette case, la fiche d'identité de votre projet sera visible sur le site du 'cadre de référence des villes et territoires durables', favorisant la mise en réseau des collectivités européennes ayant des expériences en matière d'aménagement durable."
)
commune = forms.ModelChoiceField(
label="Commune principale",
help_text=u"Sur quelle commune est situé l'ÉcoQuartier",
queryset=Commune.objects.all(),
widget=autocomplete.ModelSelect2(url='commune-autocomplete'))
communes = forms.ModelMultipleChoiceField(
label="Autres communes",
help_text="Si le projet est sur plusieurs communes",
queryset=Commune.objects.all(),
widget=autocomplete.ModelSelect2Multiple(url='commune-autocomplete'),
required=False)
coordonnees_geographiques = GeometryCollectionField(
label="Localisation du projet",
help_text=u"Dessiner sur la carte la zone où se trouve votre projet",
)
type_operations = forms.ModelMultipleChoiceField(
label=u"Type d'opérations (plusieurs choix possibles)",
queryset=TypeOperation.objects.all(),
widget=forms.CheckboxSelectMultiple(),
required=False)
vocations = forms.ModelMultipleChoiceField(
label=u"Vocations (plusieurs choix possibles)",
queryset=Vocation.objects.all(),
widget=forms.CheckboxSelectMultiple(),
required=False)
demarches = forms.ModelMultipleChoiceField(
label=
u"Engagement dans d'autres démarches de développement durable (plusieurs choix possibles)",
queryset=Demarche.objects.all(),
widget=forms.CheckboxSelectMultiple(),
required=False)
tags = forms.ModelMultipleChoiceField(
label=
u"Points forts du projet (plusieurs choix possibles dans la limite de 5)",
queryset=Tag.objects.all(),
widget=forms.CheckboxSelectMultiple(),
required=False)
class Meta:
model = Project
fields = [
'nom', 'commune', 'communes', 'project_manager_lastname',
'project_manager_firstname', 'project_manager_mail',
'project_manager_structure', 'project_developer_lastname',
'project_developer_firstname', 'project_developer_mail',
'project_developer_structure', 'plusieurs_tranches',
'coordonnees_geographiques', 'type_operations', 'vocations',
'procedure', 'description', 'demarches', 'demarches_autres',
'tags', 'charte'
]
class VectorTileForm(TileForm):
clip = forms.BooleanField(required=False, initial=True)
format = forms.CharField(required=False)
def select(self):
data = self.cleaned_data
self.queryset = self.queryset.tile(data['bbox'], data['z'],
data['format'], data['clip'])
class SignupAgreementForm(forms.ModelForm):
check1 = forms.BooleanField()
check2 = forms.BooleanField()
check3 = forms.BooleanField()
check4 = forms.BooleanField()
check5 = forms.BooleanField()
check6 = forms.BooleanField()
accepted_agreement = forms.BooleanField()
message = forms.CharField()
def __init__(self, *args, **kwargs):
self.user = kwargs.pop('user')
super(SignupAgreementForm, self).__init__(*args, **kwargs)
self.fields['message'].required = (self.user.role == 'requester')
def clean(self):
cleaned_data = super(SignupAgreementForm, self).clean()
msg = 'Você deve aceitar os termos para usar o site'
for field, value in cleaned_data.items():
if field != 'message' and not value:
self.add_error(field, msg)
class Meta:
model = models.User
fields = ('accepted_agreement', )
class RespuestaSinoForm(forms.Form):
"""!
Clase que permite crear el formulario para las respuestas de tipo SiNo
@author Manuel Zambrano
@copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
@date 29-08-2018
@version 1.0.0
"""
respuesta = forms.BooleanField(label='Respuesta',
widget=forms.Select(choices=((True, 'Si'),
(False,
'No'))),
required=False)
justificacion = forms.CharField(
label='Respuesta',
widget=forms.Textarea(),
required=False,
min_length=128,
)
def __init__(self, *arg, **kwargs):
"""!
Funcion que muestra el init del formulario
@author Manuel Zambrano
@copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
@date 29-08-2018
@version 1.0.0
"""
super(RespuestaSinoForm, self).__init__(*arg, **kwargs)
self.fields['justificacion'].widget.attrs.update({
'placeholder':
'Justificacion',
'style':
'width:370px;height:191px;'
})
def clean(self):
"""!
Funcion que sobreescribe el metodo clean() de la clase, validación para el campo de justificacion
@author Manuel Zambrano
@copyright <a href='http://www.gnu.org/licenses/gpl-2.0.html'>GNU Public License versión 2 (GPLv2)</a>
@date 29-08-2018
@version 1.0.0
"""
cleaned_data = super(RespuestaSinoForm, self).clean()
clean_respuesta = cleaned_data.get('respuesta')
clean_justificacion = cleaned_data.get('justificacion')
if not clean_respuesta:
if not clean_justificacion:
raise forms.ValidationError(
"Verifique el campo de justificacion",
code="justificacion_error")
class BasicInformationForm(forms.ModelForm):
"""Form for Basic Information model."""
name = forms.CharField(
required=True,
label='Your name',
widget=forms.TextInput(attrs={'placeholder': 'John Doe'}))
email = forms.EmailField(
required=True,
label='Your email',
widget=forms.EmailInput(attrs={
'readonly': 'readonly',
'placeholder': '*****@*****.**'
}))
image = forms.ImageField(required=False, widget=CustomClearableFileInput())
website = forms.URLField(
required=False,
label='Your website',
widget=forms.URLInput(attrs={'placeholder': 'http://john.doe.com'}))
inasafe_roles = forms.ModelMultipleChoiceField(
required=True,
label='Your InaSAFE role(s)',
queryset=InasafeRole.objects.filter(sort_number__gte=1),
widget=forms.CheckboxSelectMultiple)
osm_roles = forms.ModelMultipleChoiceField(
required=False,
label='Your OSM role(s)',
queryset=OsmRole.objects.filter(sort_number__gte=1),
widget=forms.CheckboxSelectMultiple)
osm_username = forms.CharField(
required=False,
label='OSM Username',
widget=forms.TextInput(attrs={'placeholder': 'johndoe'}))
email_updates = forms.BooleanField(
required=False, label='Receive project news and updates')
location = forms.PointField(label='Click your location on the map',
widget=LeafletWidget())
class Meta:
"""Association between models and this form."""
model = User
fields = [
'name', 'email', 'image', 'website', 'inasafe_roles', 'osm_roles',
'osm_username', 'location', 'email_updates'
]
def save(self, commit=True):
"""Save form.
:param commit: Whether committed to db or not.
:type commit: bool
"""
user = super(BasicInformationForm, self).save(commit=False)
if commit:
user.save()
return user
def __init__(self, *args, **kwargs):
extra = kwargs.pop('extra', None)
feature = kwargs.pop('feature', None)
super().__init__(*args, **kwargs)
for custom_field in extra.order_by('position'):
if custom_field.field_type == 'boolean':
self.fields[custom_field.name] = forms.BooleanField(
label=custom_field.label,
initial=False,
required=False,
)
if custom_field.field_type == 'char':
self.fields[custom_field.name] = forms.CharField(
label=custom_field.label, max_length=256, required=False)
if custom_field.field_type == 'date':
self.fields[custom_field.name] = forms.DateField(
label=custom_field.label,
required=False,
)
if custom_field.field_type == 'integer':
self.fields[custom_field.name] = forms.IntegerField(
label=custom_field.label, required=False)
if custom_field.field_type == 'decimal':
self.fields[custom_field.name] = forms.DecimalField(
label=custom_field.label,
required=False,
widget=forms.TextInput(attrs={'localization': False}))
if custom_field.field_type == 'text':
self.fields[custom_field.name] = forms.CharField(
label=custom_field.label,
required=False,
widget=forms.Textarea())
if custom_field.field_type == 'list' and custom_field.options:
self.fields[custom_field.name] = forms.ChoiceField(
label=custom_field.label,
choices=[(str(xx), str(xx))
for xx in custom_field.options],
required=False)
self.fields[custom_field.name].widget.attrs.update(
{'field_type': custom_field.field_type})
if feature and isinstance(feature.feature_data, dict):
for custom_field in extra:
self.fields[
custom_field.name].initial = feature.feature_data.get(
custom_field.name)
class ContextLayerForm(forms.ModelForm):
layer = forms.ModelChoiceField(
label="Couche", queryset=Layer.objects.all(), empty_label=None)
queryable = forms.BooleanField(label='Requêtable', required=False)
class Meta:
model = ContextLayer
fields = ['layer', 'order', 'opacity', 'queryable']
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields['order'].widget = HiddenInput()
class BasicInformationForm(forms.ModelForm):
"""Form for Basic Information model."""
name = forms.CharField(
required=True,
label='Your name',
widget=forms.TextInput(
attrs={
'placeholder': 'John Doe'})
)
email = forms.EmailField(
required=True,
label='Your email',
widget=forms.EmailInput(
attrs={
'readonly': 'readonly',
'placeholder': '*****@*****.**'})
)
website = forms.URLField(
required=False,
label='Your website',
widget=forms.URLInput(
attrs={
'placeholder': 'http://john.doe.com'})
)
role = forms.ModelChoiceField(
label='Your role',
queryset=Role.objects.filter(sort_number__gte=1),
initial=1)
email_updates = forms.BooleanField(
required=False,
label='Receive project news and updates')
location = forms.PointField(
label='Click your location on the map',
widget=LeafletWidget())
class Meta:
"""Association between models and this form."""
model = User
fields = ['name', 'email', 'website', 'role', 'location',
'email_updates']
def save(self, commit=True):
"""Save form.
:param commit: Whether committed to db or not.
:type commit: bool
"""
user = super(BasicInformationForm, self).save(commit=False)
if commit:
user.save()
return user
class RefundableAppointmentForm(forms.ModelForm):
refund_payment = forms.BooleanField(required=False)
refund_reason = forms.CharField(widget=forms.Textarea, required=False)
def clean(self):
super().clean()
cleaned_data = self.cleaned_data
refund_payment = cleaned_data.get('refund_payment')
refund_reason = cleaned_data.get('refund_reason')
if refund_payment:
if not refund_reason:
raise forms.ValidationError("Refund reason is compulsory")
if self.instance and not self.instance.status == self.instance.COMPLETED:
raise forms.ValidationError(
"Refund can be processed after Completion")
# TODO : No refund should already be in process
return cleaned_data
class VectorTileForm(TileForm):
clip = forms.BooleanField(required=False, initial=False)
format = forms.CharField(required=False)
# Geometry simplification tolerances based on tile zlevel, see
# http://wiki.openstreetmap.org/wiki/Slippy_map_tilenames.
tolerances = [
6378137 * 2 * math.pi / (2**(zoom + 8)) for zoom in range(20)
]
def select(self):
data = self.cleaned_data
try:
tolerance = self.tolerances[data['z']]
except IndexError:
tolerance = self.tolerances[-1]
self.queryset = self.queryset.tile(data['bbox'], tolerance,
data['format'], data['clip'])
class form(forms.ModelForm):
record_change = forms.BooleanField(initial=True)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.fields["text_value"].widget.attrs["rows"] = 2
self.fields["text_value"].required = False
self.fields["date_value"].required = False
if getattr(self, "instance", None) and self.instance.pk:
self.fields["name"].disabled = True
else:
self.fields["record_change"].widget = forms.HiddenInput()
def is_valid(self):
print(self.instance, self.instance.text_value)
result = super().is_valid()
print(self.instance, self.instance.text_value)
return result
class LayerForm(forms.ModelForm):
auto_calculate_envelope = forms.BooleanField(
initial=True,
help_text="""If True, the geometry envelope will be calculated
automatically from the contents of the GeoJSON.
""")
class Meta:
model = Layer
fields = "__all__"
def save(self, commit=True):
m = super().save(commit=False)
if self.fields["auto_calculate_envelope"]:
gc = geometry_from_url(self.fields["url"])
# TODO Add a buffer to the envelope? (gc.envelope.buffer)
m.envelope = gc.envelope
if commit:
m.save()
return m
class MerchantPayoutForm(forms.ModelForm):
process_payout = forms.BooleanField(required=False)
recreate_payout = forms.BooleanField(required=False)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
payment_mode_options = []
instance = self.instance
merchant = instance.get_merchant()
if merchant and merchant.ifsc_code and self.fields.get('payment_mode'):
ifsc_code = merchant.ifsc_code
if ifsc_code.upper().startswith(
MerchantPayout.INTRABANK_IDENTIFIER):
payment_mode_options = [(MerchantPayout.IFT,
MerchantPayout.IFT)]
else:
payment_mode_options = [
(MerchantPayout.NEFT, MerchantPayout.NEFT),
(MerchantPayout.IMPS, MerchantPayout.IMPS)
]
self.fields.get('payment_mode').choices = payment_mode_options
def clean(self):
super().clean()
if any(self.errors):
return
request = self.request
user_groups = request.user.groups.values_list('name', flat=True)
if 'qc_merchant_team' in user_groups and 'merchant_team' not in user_groups:
raise forms.ValidationError(
"You are not authorized to perform this action.")
else:
if self.cleaned_data.get(
'type', None
) == MerchantPayout.MANUAL and not self.cleaned_data.get(
'utr_no', None):
raise forms.ValidationError(
"Enter UTR Number if payout type is manual.")
if not self.cleaned_data.get(
'type', None) == MerchantPayout.MANUAL and (
self.cleaned_data.get('utr_no', None)
or self.cleaned_data.get('amount_paid', None)):
raise forms.ValidationError(
"No need for UTR Number/Amount Paid if payout type is not manual."
)
process_payout = self.cleaned_data.get('process_payout')
if process_payout:
if not self.instance.get_merchant():
raise forms.ValidationError(
"No verified merchant found to process payments")
merchant = self.instance.get_merchant()
if not merchant.verified_by_finance or not merchant.enabled:
raise forms.ValidationError(
"Merchant is not verified or is not enabled.")
billed_to = self.instance.get_billed_to()
if not billed_to:
raise forms.ValidationError("Billing entity not defined.")
if not self.instance.booking_type == self.instance.InsurancePremium:
if self.instance.payout_type == 1:
associated_merchant = billed_to.merchant.first()
if not associated_merchant:
self.instance.update_billed_to_content_type()
if associated_merchant and not associated_merchant.verified:
raise forms.ValidationError(
"Associated Merchant not verified.")
if self.instance.status not in [1, 2]:
raise forms.ValidationError(
"Only pending and attempted payouts can be processed.")
recreate_payout = self.cleaned_data.get('recreate_payout')
if recreate_payout:
if self.instance.status not in [
6, 7
] and not self.instance.merchant_has_advance_payment():
raise forms.ValidationError(
"Only failed or advance paid payout can be re-created."
)
if self.instance.status in [3, 4, 5]:
raise forms.ValidationError(
"This payout is already under process or completed.")
return self.cleaned_data
class RegistrationForm(forms.ModelForm):
"""Form for user model."""
name = forms.CharField(
required=True,
label='Your name',
widget=forms.TextInput(
attrs={'placeholder': 'John Doe'})
)
email = forms.EmailField(
required=True,
label='Your email',
widget=forms.EmailInput(
attrs={
'placeholder': '*****@*****.**'})
)
password = forms.CharField(
required=True,
label='Your password',
widget=forms.PasswordInput()
)
password2 = forms.CharField(
required=True,
label='Your password (again)',
widget=forms.PasswordInput()
)
website = forms.URLField(
required=False,
label='Your website',
widget=forms.URLInput(
attrs={'placeholder': 'http://john.doe.com'})
)
location = forms.PointField(
label='Click your location on the map',
widget=LeafletWidget())
role = forms.ModelChoiceField(
label='Your role',
queryset=Role.objects.filter(sort_number__gte=1),
initial=1)
email_updates = forms.BooleanField(
required=False,
label='Receive project news and updates')
class Meta:
"""Association between models and this form."""
model = User
fields = ['name', 'email', 'password', 'password2', 'website', 'role',
'location', 'email_updates']
def clean(self):
"""Verifies that the values entered into the password fields match."""
cleaned_data = super(RegistrationForm, self).clean()
if 'password' in cleaned_data and 'password2' in cleaned_data:
if cleaned_data['password'] != cleaned_data['password2']:
raise forms.ValidationError(
"Passwords don't match. Please enter both fields again.")
return cleaned_data
def save(self, commit=True):
"""Save form.
:param commit: Whether committed to db or not.
:type commit: bool
"""
user = super(RegistrationForm, self).save(commit=False)
user.set_password(self.cleaned_data['password'])
if commit:
user.save()
return user
class RegistrationForm(forms.ModelForm):
"""Form for user model."""
name = forms.CharField(
required=True,
label='Name',
widget=forms.TextInput(attrs={'placeholder': 'John Doe'}))
email = forms.EmailField(
required=True,
label='Email',
widget=forms.EmailInput(attrs={'placeholder': '*****@*****.**'}))
image = forms.ImageField(required=False, widget=CustomClearableFileInput())
password = forms.CharField(required=True,
label='Password',
widget=forms.PasswordInput())
password2 = forms.CharField(required=True,
label='Password (again)',
widget=forms.PasswordInput())
website = forms.URLField(
required=False,
label='Website',
widget=forms.URLInput(attrs={'placeholder': 'http://john.doe.com'}))
inasafe_roles = forms.ModelMultipleChoiceField(
required=True,
label='Your InaSAFE role(s)',
queryset=InasafeRole.objects.all(),
widget=forms.CheckboxSelectMultiple)
osm_roles = forms.ModelMultipleChoiceField(
required=False,
label='Your OSM role(s)',
queryset=OsmRole.objects.all(),
widget=forms.CheckboxSelectMultiple)
osm_username = forms.CharField(
required=False,
label='OSM Username',
widget=forms.TextInput(attrs={'placeholder': 'johndoe'}))
location = forms.PointField(
label='Draw a marker as your location on the map',
widget=LeafletWidget())
email_updates = forms.BooleanField(
required=False, label='Receive project news and updates')
class Meta:
"""Association between models and this form."""
model = User
fields = [
'name', 'email', 'image', 'password', 'password2', 'website',
'inasafe_roles', 'osm_roles', 'osm_username', 'location',
'email_updates'
]
def clean(self):
"""Verifies that the values entered into the password fields match."""
cleaned_data = super(RegistrationForm, self).clean()
if 'password' in cleaned_data and 'password2' in cleaned_data:
if cleaned_data['password'] != cleaned_data['password2']:
raise forms.ValidationError(
"Passwords don't match. Please enter both fields again.")
return cleaned_data
def save(self, commit=True):
"""Save form.
:param commit: Whether committed to db or not.
:type commit: bool
"""
user = super(RegistrationForm, self).save(commit=False)
user.set_password(self.cleaned_data['password'])
if commit:
user.save()
return user
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
for attribute in Attribute.objects.all():
self.fields[attribute.attribute] = forms.BooleanField(
initial=False, required=False)
class ProjectModelForm(forms.ModelForm):
title = forms.CharField(label='Titre', max_length=100)
thumbnail = forms.ImageField(label="Illustration du projet", required=False)
description = forms.CharField(
label='Description', required=False, widget=forms.Textarea())
moderation = forms.BooleanField(label='Modération', required=False)
is_project_type = forms.BooleanField(
label="Est un projet type", required=False)
archive_feature = forms.IntegerField(
label='Délai avant archivage', required=False)
delete_feature = forms.IntegerField(
label='Délai avant suppression', required=False)
access_level_pub_feature = forms.ModelChoiceField(
label='Visibilité des signalements publiés',
queryset=UserLevelPermission.objects.filter(rank__lte=2).order_by('rank'),
empty_label=None,)
access_level_arch_feature = forms.ModelChoiceField(
label='Visibilité des signalements archivés',
queryset=UserLevelPermission.objects.filter(rank__lte=4).order_by('rank'),
empty_label=None,)
create_from = forms.CharField(required=False, widget=HiddenInput())
class Meta:
model = Project
fields = [
'title',
'description',
'moderation',
'thumbnail',
'access_level_pub_feature',
'access_level_arch_feature',
'archive_feature',
'delete_feature',
'is_project_type',
'create_from',
]
def __init__(self, *args, **kwargs):
slug = kwargs.pop('create_from', None)
project_type = Project.objects.filter(slug=slug).first()
super().__init__(*args, **kwargs)
instance = kwargs.get('instance')
if instance:
# Optionnel
for key in ['archive_feature', 'delete_feature']:
source = getattr(instance, key)
self.fields[key].initial = source
elif project_type:
for key in [
'archive_feature', 'delete_feature',
'access_level_pub_feature', 'access_level_arch_feature',
'description', 'moderation', 'thumbnail']:
source = getattr(project_type, key)
self.fields[key].initial = source
self.fields['title'].initial = "{} (Copie-{})".format(
project_type.title, timezone.now().strftime("%d/%m/%Y %H:%M")
)
self.fields['title'].help_text = "Le titre d'un projet doit etre unique. "
self.fields['create_from'].initial = slug
else:
self.fields['archive_feature'].initial = 0
self.fields['delete_feature'].initial = 0
def clean_title(self):
title = self.cleaned_data.get('title')
if self.instance.pk:
if Project.objects.filter(title=title).exclude(pk=self.instance.pk).exists():
msg = "Veuillez modifier le titre de votre projet, un projet avec ce titre existe déjà."
raise forms.ValidationError(msg)
else:
if Project.objects.filter(title=title).exists():
msg = "Veuillez modifier le titre de votre projet, un projet avec ce titre existe déjà."
raise forms.ValidationError(msg)
return title
def clean(self):
cleaned_data = super().clean()
archive_feature = cleaned_data.get('archive_feature', None)
delete_feature = cleaned_data.get('delete_feature', None)
if archive_feature and delete_feature and archive_feature > delete_feature:
raise forms.ValidationError({
'archive_feature': "Le délais de suppression doit être supérieur au délais d'archivage. "
})
return cleaned_data
class ProjectModelForm(forms.ModelForm):
title = forms.CharField(label='Titre', max_length=100)
thumbnail = forms.ImageField(label="Illustration du projet",
required=False)
description = forms.CharField(label='Description',
required=False,
widget=forms.Textarea())
moderation = forms.BooleanField(label='Modération', required=False)
archive_feature = forms.IntegerField(label='Délai avant archivage',
required=False)
delete_feature = forms.IntegerField(label='Délai avant suppression',
required=False)
access_level_pub_feature = forms.ModelChoiceField(
label='Visibilité des signalements publiés',
queryset=UserLevelPermission.objects.filter(
rank__lte=2).order_by('rank'),
empty_label=None,
)
access_level_arch_feature = forms.ModelChoiceField(
label='Visibilité des signalements archivés',
queryset=UserLevelPermission.objects.filter(
rank__lte=4).order_by('rank'),
empty_label=None,
)
class Meta:
model = Project
fields = [
'title',
'description',
'moderation',
'thumbnail',
'access_level_pub_feature',
'access_level_arch_feature',
'archive_feature',
'delete_feature',
]
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
instance = kwargs.get('instance')
if instance:
self.fields['archive_feature'].initial = instance.archive_feature
self.fields['delete_feature'].initial = instance.delete_feature
else:
self.fields['archive_feature'].initial = 0
self.fields['delete_feature'].initial = 0
def clean_title(self):
title = self.cleaned_data.get('title')
if self.instance.pk:
if Project.objects.filter(title=title).exclude(
pk=self.instance.pk).exists():
msg = "Veuillez modifier le titre de votre projet, un projet avec ce titre existe déjà."
raise forms.ValidationError(msg)
else:
if Project.objects.filter(title=title).exists():
msg = "Veuillez modifier le titre de votre projet, un projet avec ce titre existe déjà."
raise forms.ValidationError(msg)
return title
def clean(self):
cleaned_data = super().clean()
archive_feature = cleaned_data.get('archive_feature', None)
delete_feature = cleaned_data.get('delete_feature', None)
if archive_feature and delete_feature and archive_feature > delete_feature:
raise forms.ValidationError(
"Le délai d'archivage doit être inférieur au délai de suppression. "
)
return cleaned_data
