class AuthorizationForm(forms.ModelForm):
first_name = forms.CharField(label="Nom", required=False)
last_name = forms.CharField(label="Prenom", required=False)
username = forms.CharField(label="Nom d'utilisateur")
level = forms.ModelChoiceField(
label="Niveau d'autorisation",
queryset=UserLevelPermission.objects.filter(rank__gte=1).order_by('rank'),
empty_label=None)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if self.instance and hasattr(self.instance, 'user'):
self.fields['first_name'].initial = self.instance.user.first_name
self.fields['last_name'].initial = self.instance.user.last_name
self.fields['level'].initial = self.instance.level
self.fields['username'].initial = self.instance.user.username
self.fields['first_name'].disabled = True
self.fields['last_name'].disabled = True
self.fields['username'].disabled = True
class Meta:
model = Authorization
fields = (
'first_name',
'last_name',
'username',
'level',
)
class RespuestaOpcionesForm(forms.Form):
"""!
Clase que permite crear el formulario para las respuestas de tipo Opciones
@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.ModelChoiceField(label='Opcion',
queryset=Opcion.objects.all(),
required=True,
empty_label=None)
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(RespuestaOpcionesForm, self).__init__(*arg, **kwargs)
class FeatureLinkForm(forms.ModelForm):
feature_to = forms.ModelChoiceField(
label="Signalement lié", queryset=Feature.objects.all(),
empty_label=None)
class Meta:
model = FeatureLink
fields = (
'relation_type',
'feature_to',
)
def __init__(self, *args, **kwargs):
feature_type = kwargs.pop('feature_type', None)
feature = kwargs.pop('feature', None)
super().__init__(*args, **kwargs)
qs = Feature.objects.all()
if feature_type:
qs = qs.filter(
feature_type=feature_type
)
if feature:
qs = qs.exclude(
feature_id=feature.feature_id
)
try:
self.fields['feature_to'].queryset = qs
self.fields['feature_to'].label_from_instance = lambda obj: "{} ({} - {})".format(
obj.title, obj.display_creator, obj.created_on.strftime("%d/%m/%Y %H:%M"))
except Exception:
logger.exception('No related features found')
class HomeForm(forms.Form):
name = forms.CharField(
min_length=1,
max_length=255,
strip=True,
widget=forms.TextInput(attrs={'class': 'form-control'})
)
lat = forms.FloatField(
widget=forms.HiddenInput()
)
lng = forms.FloatField(
widget=forms.HiddenInput()
)
radius = forms.IntegerField(
max_value='1000000000',
min_value='5',
widget=forms.NumberInput(attrs={'class': 'form-control'}),
initial=50
)
module = forms.ModelChoiceField(
widget=forms.RadioSelect,
queryset=Module.objects.all(),
empty_label='モジュールを選択',
required=True
)
class Meta:
labels = {
'radius': 'Radius',
'name': 'Name',
'module': 'Module'
}
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 ContextLayerForm(forms.ModelForm):
layer = forms.ModelChoiceField(label="Couche",
queryset=Layer.objects.all(),
empty_label=None)
class Meta:
model = ContextLayer
fields = ['layer', 'order', 'opacity']
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 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 EmpleadoForm(forms.Form):
cedula = forms.CharField(required=False, label=u'Cédula')
nombres = forms.CharField(max_length=250,
widget=forms.TextInput(attrs={'size': '30'}))
apellido_paterno = forms.CharField(
max_length=250, widget=forms.TextInput(attrs={'size': '30'}))
apellido_materno = forms.CharField(
max_length=250,
widget=forms.TextInput(attrs={'size': '30'}),
required=False)
pais = forms.ModelChoiceField(
queryset=Pais.objects.all(),
empty_label="Escoger un pais",
widget=forms.Select(attrs={
'placeholder': 'País',
'onChange': "getProvincias(this.value)"
}))
provincia = forms.ModelChoiceField(
queryset=Provincia.objects.none(),
empty_label="Escoger una provincia",
widget=forms.Select(
attrs={
'placeholder': 'Provincia o estado',
'onChange': "getCiudades(this.value)"
}))
ciudad = forms.ModelChoiceField(
queryset=Ciudad.objects.none(),
empty_label="Escoger una ciudad",
widget=forms.Select(attrs={'placeholder': 'Ciudad o Cantón'}))
sexo = forms.ChoiceField(choices=PersonaNatural.SEXO_CHOICES,
required=True)
fecha_nacimiento = forms.DateField(required=False)
observaciones = forms.CharField(widget=forms.Textarea())
usuario = forms.CharField(max_length=13,
widget=forms.TextInput(attrs={'size': '30'}))
contrasenia = forms.CharField(
max_length=13, widget=forms.PasswordInput(attrs={'size': '30'}))
email = forms.EmailField(max_length=25,
widget=forms.TextInput(attrs={'size': '30'}))
plazas_trabajo = forms.ModelMultipleChoiceField(
queryset=PlazaTrabajo.objects.all(), widget=forms.SelectMultiple)
foto = forms.ImageField(required=False)
def modificarQuerySet(self, pais_id, provincia_id):
if pais_id not in ('', None):
self.fields['provincia'].queryset = Provincia.objects.filter(
pais__id=pais_id)
if provincia_id not in ('', None):
self.fields['ciudad'].queryset = Ciudad.objects.filter(
provincia__id=provincia_id)
def save(self, empleado=None):
cleaned_data = super(EmpleadoForm, self).clean()
if empleado is None:
persona = Persona()
persona.tipo = Persona.TIPO_PERSONA_NATURAL
persona.observaciones = cleaned_data["observaciones"]
persona.ruc = cleaned_data["cedula"]
persona.nombre_comercial = ""
persona.save()
usuario = User()
usuario.username = cleaned_data["usuario"]
usuario.set_password(cleaned_data["contrasenia"])
usuario.email = cleaned_data["email"]
usuario.save()
persona_natural = PersonaNatural()
persona_natural.ciudad_nacimiento = cleaned_data['ciudad']
persona_natural.cedula = cleaned_data["cedula"]
persona_natural.nombres = cleaned_data["nombres"]
persona_natural.apellido_paterno = cleaned_data["apellido_paterno"]
persona_natural.apellido_materno = cleaned_data["apellido_materno"]
persona_natural.persona = persona
persona_natural.sexo = cleaned_data["sexo"]
persona_natural.fecha_nacimiento = cleaned_data["fecha_nacimiento"]
persona_natural.save()
empleado = Empleado()
empleado.persona = persona_natural
empleado.usuario = usuario
empleado.foto = cleaned_data["foto"]
empleado.observaciones = cleaned_data["observaciones"]
empleado.save()
empleado.plazas_trabajo = cleaned_data["plazas_trabajo"]
empleado.save()
else:
empleado.persona.nombres = cleaned_data["nombres"]
empleado.persona.apellido_paterno = cleaned_data[
"apellido_paterno"]
empleado.persona.apellido_materno = cleaned_data[
"apellido_materno"]
empleado.persona.sexo = cleaned_data["sexo"]
empleado.persona.cedula = cleaned_data["cedula"]
empleado.persona.ciudad_nacimiento = cleaned_data["ciudad"]
empleado.persona.save()
empleado.usuario.email = cleaned_data["email"]
empleado.usuario.save()
empleado.foto = cleaned_data["foto"]
empleado.observaciones = cleaned_data["observaciones"]
empleado.save()
empleado.plazas_trabajo = cleaned_data["plazas_trabajo"]
empleado.save()
return empleado
def clean_usuario(self):
if self.cleaned_data['usuario']:
p = User.objects.filter(username=self.cleaned_data['usuario'])
if len(p) > 0:
raise forms.ValidationError(
_("Ya esxiste un usuario con este username"))
return self.cleaned_data['usuario']
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
class DealSpatialForm(BaseForm):
exclude_in_export = ['target_region', 'contract_area', 'intended_area', 'production_area']
ACCURACY_CHOICES = (
("", _("---------")),
("Country", _("Country")),
("Administrative region", _("Administrative region")),
("Approximate location", _("Approximate location")),
("Exact location", _("Exact location")),
("Coordinates", _("Coordinates")),
)
AREA_FIELDS = (
'contract_area',
'intended_area',
'production_area',
)
form_title = _('Location')
tg_location = TitleField(
required=False, label="", initial=_("Location"))
level_of_accuracy = forms.ChoiceField(
required=False, label=_("Spatial accuracy level"),
choices=ACCURACY_CHOICES)
location = forms.CharField(
required=True, label=_("Location"), widget=LocationWidget)
point_lat = forms.CharField(
required=False, label=_("Latitude"), widget=forms.TextInput,
initial="")
point_lon = forms.CharField(
required=False, label=_("Longitude"), widget=forms.TextInput,
initial="")
facility_name = forms.CharField(
required=False, label=_("Facility name"), widget=forms.TextInput,
initial="")
target_country = CountryField(required=False, label=_("Target Country"))
target_region = forms.ModelChoiceField(
required=False, label=_("Target Region"), widget=forms.HiddenInput,
queryset=Region.objects.all().order_by("name"))
location_description = forms.CharField(
required=False, label=_("Location description"),
widget=forms.TextInput, initial="")
contract_area = AreaField(required=False, label=_("Contract area"))
intended_area = AreaField(required=False, label=_("Intended area"))
production_area = AreaField(required=False, label=_("Area in operation"))
tg_location_comment = forms.CharField(
required=False, label=_("Comment on Location"), widget=CommentInput)
class Meta:
name = 'location'
def __init__(self, *args, **kwargs):
'''
Pass the values we need through to map widgets
'''
super().__init__(*args, **kwargs)
lat_lon_attrs = self.get_default_lat_lon_attrs()
# Bind area maps to the main location map
area_attrs = {
'bound_map_field_id': '{}-map'.format(self['location'].html_name)
}
area_attrs.update(lat_lon_attrs)
location_attrs = self.get_location_map_widget_attrs()
location_attrs.update(lat_lon_attrs)
if area_attrs:
for polygon_field in self.AREA_FIELDS:
widget = AreaWidget(map_attrs=area_attrs)
self.fields[polygon_field].widget = widget
# Public field gets a mapwidget, so check for that
if isinstance(self.fields['location'].widget, MapWidget):
self.fields['location'].widget = MapWidget(attrs=location_attrs)
else:
self.fields['location'].widget = LocationWidget(
map_attrs=location_attrs)
def get_location_map_widget_attrs(self):
attrs = {
'show_layer_switcher': True,
}
bound_fields = (
('location', 'bound_location_field_id'),
('target_country', 'bound_target_country_field_id'),
('level_of_accuracy', 'bound_level_of_accuracy_field_id'),
('point_lat', 'bound_lat_field_id'),
('point_lon', 'bound_lon_field_id'),
)
for field, attr in bound_fields:
try:
attrs[attr] = self[field].auto_id
except KeyError:
pass
return attrs
def get_default_lat_lon_attrs(self):
attrs = {}
try:
lat = float(self['point_lat'].value())
except ValueError:
lat = None
try:
lon = float(self['point_lon'].value())
except ValueError:
lon = None
if lat and lon:
attrs.update({
'initial_center_lon': lon,
'initial_center_lat': lat,
'initial_point': [lon, lat],
})
return attrs
def clean_area_field(self, field_name):
value = self.cleaned_data[field_name]
try:
# Check if we got a file here, as
value.name
value.size
except AttributeError:
value_is_file = False
else:
value_is_file = True
if value_is_file:
# Files are the second widget, so append _1
field_name = '{}_1'.format(self[field_name].html_name)
shapefile_data = hasattr(self.files, 'getlist') and self.files.getlist(field_name) or self.files[field_name]
try:
value = parse_shapefile(shapefile_data)
except ValueError as err:
error_msg = _('Error parsing shapefile: %s') % err
raise forms.ValidationError(error_msg)
return value
def clean_contract_area(self):
return self.clean_area_field('contract_area')
def clean_intended_area(self):
return self.clean_area_field('intended_area')
def clean_production_area(self):
return self.clean_area_field('production_area')
def get_attributes(self, request=None):
attributes = super().get_attributes()
# For polygon fields, pass the value directly
for field_name in self.AREA_FIELDS:
polygon_value = self.cleaned_data.get(field_name)
attributes[field_name] = {'polygon': polygon_value}
return attributes
@classmethod
def get_data(cls, activity, group=None, prefix=""):
data = super().get_data(activity, group=group, prefix=prefix)
for area_field_name in cls.AREA_FIELDS:
area_attribute = activity.attributes.filter(
fk_group__name=group, name=area_field_name).first()
if area_attribute:
data[area_field_name] = area_attribute.polygon
return data
def get_fields_display(self):
fields = super().get_fields_display()
# Hide coordinates depending on level of accuracy
accuracy = self.initial.get('level_of_accuracy', '')
if accuracy in ('Country', 'Administrative region', 'Approximate location'):
for field in fields:
if field['name'] in ('point_lat', 'point_lon'):
field['hidden'] = True
return fields
class PlaceForm(forms.Form):
place_name = forms.CharField(label='Place Name', max_length=100)
type = forms.ModelChoiceField(label='Place Type',
queryset=BistroType.objects.all())
location = forms.PointField(widget=BootstrapMapWidget(), required=False)
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
