class OrgSearch(forms.Form):
org_type = forms.ChoiceField(choices=ORG_TYPE_CHOICES, required=False)
prov_type = forms.ModelChoiceField(queryset=AgreementIAE.objects.all(),
empty_label=u'Tout voir',
required=False)
interim = forms.BooleanField(required=False)
sector = forms.ModelChoiceField(
queryset=ActivityNomenclature.objects.filter(level=0),
empty_label=u'Tout voir',
required=False)
area = AutoCompleteSelectField(lookup_class=AreaLookup, required=False)
radius = forms.IntegerField(required=False)
q = forms.CharField(
required=False,
widget=forms.TextInput(attrs={
'class': 'form-control',
'placeholder': 'Recherche libre : mot clés'
}))
def __init__(self, *args, **kwargs):
super(OrgSearch, self).__init__(*args, **kwargs)
for name, field in self.fields.iteritems():
if name == 'interim':
continue
field.widget.attrs['class'] = 'form-control'
self.fields['area'].widget.attrs['placeholder'] = u'Tout voir'
self.fields['area'].widget.attrs[
'class'] = u'form-control form-control-small'
self.fields['radius'].widget.attrs['placeholder'] = u'Dans un rayon de'
self.fields['radius'].widget.attrs[
'class'] = u'form-control form-control-small'
class CallSearch(forms.Form):
org_type = forms.ChoiceField(choices=ORG_TYPE_CHOICES, required=False)
clause = forms.ChoiceField(choices=(('', u'Tout voir'), ) + CLAUSE_CHOICES, required=False)
organization = forms.ModelChoiceField(queryset=Organization.objects.filter(is_customer=True, status=ORGANIZATION_STATUSES.VALIDATED), required=False, empty_label=u'Toutes')
sector = forms.ModelChoiceField(queryset=ActivityNomenclature.objects.filter(level=0), empty_label=u'Tout voir', required=False)
period = forms.ChoiceField(choices=PERIOD_CHOICES, required=False)
q = forms.CharField(required=False)
def __init__(self, *args, **kwargs):
super(CallSearch, self).__init__(*args, **kwargs)
for field in self.fields.itervalues():
field.widget.attrs['class'] = 'form-control'
class GradebookFilterForm(forms.Form):
cohort = forms.ModelChoiceField(
queryset=None,
widget=forms.Select(
attrs={'onchange': 'submit_filter_form(this.form)'}),
required=False)
marking_period = forms.ModelChoiceField(
queryset=None,
widget=forms.Select(
attrs={'onchange': 'submit_filter_form(this.form)'}),
required=False)
benchmark = forms.ModelMultipleChoiceField(
queryset=None,
required=False,
widget=forms.SelectMultiple(attrs={'class': 'simple_multiselect'}))
category = forms.ModelChoiceField(
queryset=None,
widget=forms.Select(
attrs={'onchange': 'submit_filter_form(this.form)'}),
required=False)
assignment_type = forms.ModelChoiceField(
queryset=None,
widget=forms.Select(
attrs={'onchange': 'submit_filter_form(this.form)'}),
required=False)
name = forms.CharField(required=False)
date_begin = forms.DateField(
required=False,
widget=forms.DateInput(attrs={'placeholder': 'Later than'}),
validators=settings.DATE_VALIDATORS)
date_end = forms.DateField(
required=False,
widget=forms.DateInput(attrs={'placeholder': 'Earlier than'}),
validators=settings.DATE_VALIDATORS)
def update_querysets(self, course_section):
self.fields['cohort'].queryset = Cohort.objects.filter(
Q(percoursesectioncohort=None,
student__coursesection=course_section)
| Q(percoursesectioncohort__coursesection=course_section)
).distinct().order_by('name')
self.fields['marking_period'].queryset = MarkingPeriod.objects.filter(
coursesection=course_section).distinct()
self.fields['benchmark'].queryset = Benchmark.objects.filter(
item__course_section=course_section).distinct()
self.fields[
'assignment_type'].queryset = AssignmentType.objects.filter(
item__course_section=course_section).distinct()
self.fields['category'].queryset = Category.objects.filter(
item__course_section=course_section).distinct()
class StudentBulkChangeForm(forms.Form):
grad_date = forms.DateField(widget=adminwidgets.AdminDateWidget(),
required=False,
validators=settings.DATE_VALIDATORS)
year = forms.ModelChoiceField(queryset=GradeLevel.objects.all(),
required=False)
individual_education_program = forms.NullBooleanField(required=False)
cohort = forms.ModelChoiceField(queryset=Cohort.objects.all(),
required=False)
cohort_primary = forms.BooleanField(required=False)
award = forms.ModelChoiceField(queryset=Award.objects.all(),
required=False)
award_marking_period = forms.ModelChoiceField(
queryset=MarkingPeriod.objects.all(), required=False)
class AlbaranSalidaForms(forms.ModelForm):
class Meta:
model = Albaran
exclude = ('user', 'fechaalta')
def __init__(self, *args, **kwargs):
self.helper = FormHelper()
self.helper.form_tag = False
self.helper.layout = Layout(
Fieldset(
Field('id'),
Div(Div('tpdoc', css_class=s4),
Div(Field('referencia')),
css_class=s12),
Div(Field('proveedor', css_class=s12), css_class=s12),
Div(Field('fecha', template=fecha), css_class=s12),
Div(Field('observaciones', template=editor), css_class=s12)),
#FormActions( Submit( "Update","Guardar"), Button( "cancel","Cancelar"))
)
super(AlbaranSalidaForms, self).__init__(*args, **kwargs)
self.fields['fecha'].widget.attrs['placeholder'] = 'dd/mm/aaaa'
self.fields['tpdoc'].widget.attrs['readonly'] = 'readonly'
self.fields['proveedor'].required = False
self.fields['proveedor'].label = "Cliente"
tpdoc = forms.ModelChoiceField(
widget=forms.Select(),
queryset=TiposDocumentos.objects.filter(abrv="ALBOUT"),
initial=0)
proveedor = autocomplete_light.ModelChoiceField(
'TercerosAutocompleteClientesTerceros')
class UserForm(forms.Form):
age = forms.IntegerField(
label="Tuổi",
required=True
)
sex = forms.ModelChoiceField(
queryset=Sex.objects.all(),
label=u'Giới tính',
empty_label=None
)
height = forms.DecimalField(
label="Chiều cao",
required=True,
widget=forms.NumberInput(
attrs={'placeholder': 'Đơn vị là cm'}
)
)
weight = forms.DecimalField(
label="Cân nặng",
required=True,
widget=forms.NumberInput(
attrs={'placeholder': 'Đơn vị là kg'}
)
)
activity_level = forms.ModelChoiceField(
queryset=ActivityLevel.objects.all(),
label=u'Mức độ hoạt động',
empty_label=None,
)
def __init__(self, *args, **kwargs):
super(UserForm, self).__init__(*args, **kwargs)
self.helper = FormHelper()
self.helper.form_class = "form-horizontal"
self.helper.form_method = 'post'
self.helper.form_action = ''
self.helper.html5_required = True
self.helper.layout = Layout(
'age',
'height',
'weight',
InlineRadios('sex'),
'activity_level',
)
self.helper.add_input(Submit('submit', 'Tư vấn'))
class CadenaModelForm(forms.ModelForm, CleanNombreMixin):
model_related = Cadena
cadena_madre = forms.ModelChoiceField(Cadena.objects.all(),
label=u'Pertenece a', required=False,
help_text=u'Por ejemplo, Jumbo y Vea son de Cencosud') # noqa
class Meta:
model = Cadena
fields = ['cadena_madre', 'nombre']
class StepModelForm(ModelForm):
activity = forms.ModelChoiceField(queryset=Activity.objects.filter(
Q(public=True) | Q(public=False, team=team)).order_by('team'),
required=True)
duration = forms.IntegerField(
required=False, widget=forms.TextInput(attrs={'class': 'order'}))
class Meta:
model = Step
class SucursalModelForm(forms.ModelForm, CleanNombreMixin):
model_related = Sucursal
max_cantidad_palabras = 4
max_largo = 30
puede_ser_vacio = True
ciudad = forms.ModelChoiceField(
City.objects.all(), widget=autocomplete_light.ChoiceWidget('CityAutocomplete'))
ubicacion = forms.gis.PointField(widget=PointWidget, required=False)
class Meta:
model = Sucursal
fields = ('cadena', 'nombre', 'ciudad', 'direccion', 'ubicacion', 'cp',
'telefono', 'horarios')
class SelectSubscriptionForm(forms.Form):
subscription = forms.ModelChoiceField(queryset=Subscription.objects.all(),
required=True,
label='Select your subscription')
@property
def helper(self):
helper = FormHelper()
helper.form_method = 'post'
helper.form_class = 'form-container select-subscription-form'
helper.layout = Layout(
'subscription',
Submit('_select', _(u'Continue with checkout'),
css_class='large-'))
return helper
class OrgSearch(forms.Form):
areas = Area.objects.filter(
parent_rels__parent__label=settings.REGION_LABEL).order_by('reference')
org_type = forms.ChoiceField(choices=ORG_TYPE_CHOICES, required=False)
sector = forms.ModelChoiceField(
queryset=ActivityNomenclature.objects.filter(level=0),
empty_label=u'Secteur d\'activité',
required=False)
area_1 = AreaModelChoiceField(queryset=areas,
empty_label=u'Territoire',
required=False)
def __init__(self, *args, **kwargs):
super(OrgSearch, self).__init__(*args, **kwargs)
for field in self.fields.itervalues():
field.widget.attrs['class'] = 'form-control'
class StudentReportWriterForm(StudentSelectForm):
template = forms.ModelChoiceField(required=False,
queryset=Template.objects.all())
upload_template = forms.FileField(
required=False,
help_text="You may choose a template or upload one here")
def clean(self):
data = super(StudentReportWriterForm, self).clean()
if not data.get('student') and not data.get('all_students'):
raise forms.ValidationError(
"You must either check \"all students\" or select a student")
if not data.get('template') and not data.get('upload_template'):
raise forms.ValidationError(
"You must either select a template or upload one.")
return data
class MarcaModelForm(forms.ModelForm, CleanNombreMixin):
# flag para que el mixin distinga que modelform es
model_related = Marca
qs = EmpresaFabricante.objects.all().order_by('nombre')
# en el form lo hacemos obligatorio
fabricante = forms.ModelChoiceField(queryset=qs,
help_text='Por favor, revisá bien este campo.')
class Meta:
model = Marca
exclude = ['logo', 'logo_cropped']
help_texts = {
'nombre': 'Tiene que ser una marca nueva. '
'Si la que querés agregar aparece en la lista, '
'quiere decir que ya la conocemos.',
}
class GradeFilterForm(TimeBasedForm):
marking_period = forms.ModelMultipleChoiceField(required=False, queryset=MarkingPeriod.objects.all())
filter_choices = (
("lt", "Less Than"),
("lte", "Less Than Equals"),
("gt", "Greater Than"),
("gte", "Greater Than Equals"),
)
grade = forms.CharField(max_length=5,
widget=forms.TextInput(attrs={'placeholder': 'Enter Grade Here'}),
required=False,
help_text="P counts as 100%, F counts as 0%",)
grade_filter = forms.ChoiceField(choices=filter_choices)
grade_times = StarOrIntField(max_length=2, required=False, initial="*", widget=forms.TextInput(attrs={'style':'width:20px;'}))
final_grade = forms.CharField(max_length=5,
widget=forms.TextInput(attrs={'placeholder': 'Enter Grade Here'}),
required=False,
help_text="P counts as 100%, F counts as 0%",)
final_grade_filter = forms.ChoiceField(choices=filter_choices)
final_grade_times = StarOrIntField(max_length=2, required=False, initial="*", widget=forms.TextInput(attrs={'style':'width:20px;'}))
gpa = forms.DecimalField(max_digits=5, decimal_places=2, required=False)
gpa_equality = forms.ChoiceField(choices=filter_choices)
filter_year = forms.ModelMultipleChoiceField(required=False, queryset=GradeLevel.objects.all())
in_individual_education_program = forms.BooleanField(required=False)
#disc
if 'ecwsp.discipline' in settings.INSTALLED_APPS:
from ecwsp.discipline.models import DisciplineAction
filter_disc_action = forms.ModelChoiceField(required=False, queryset=DisciplineAction.objects.all())
filter_disc = forms.ChoiceField(choices=filter_choices, required=False)
filter_disc_times = forms.CharField(max_length=2, required=False, widget=forms.TextInput(attrs={'style':'width:20px;'}))
# Aggregated
aggregate_disc = forms.ChoiceField(choices=filter_choices, required=False)
aggregate_disc_times = forms.CharField(max_length=2, required=False, widget=forms.TextInput(attrs={'style':'width:20px;'}))
aggregate_disc_major = forms.BooleanField(required=False)
# Absences
filter_attn = forms.ChoiceField(choices=filter_choices, required=False)
filter_attn_times = forms.CharField(max_length=2, required=False, widget=forms.TextInput(attrs={'style':'width:20px;'}))
# Tardies
filter_tardy = forms.ChoiceField(choices=filter_choices, required=False)
filter_tardy_times = forms.CharField(max_length=2, required=False, widget=forms.TextInput(attrs={'style':'width:20px;'}))
class AddProductForm(ProductForm):
"""Form for adding a product."""
version = forms.CharField(required=True)
profile = forms.ModelChoiceField(queryset=model.Profile.objects.all(),
required=False,
widget=forms.Select)
def save(self, user=None):
"""Save and return the new Product; also save initial version."""
user = user or self.user
product = super(AddProductForm, self).save(user=user)
version = model.ProductVersion.objects.create(
product=product, version=self.cleaned_data["version"], user=user)
profile = self.cleaned_data.get("profile")
if profile is not None:
version.environments.add(*profile.environments.all())
return product
class EntryForm(ModuloModelForm):
author = forms.ModelChoiceField(label=_('author'),
queryset=User.objects.all(),
empty_label=None)
def __init__(self, authors_choices, categories_set, *args, **kwargs):
super(EntryForm, self).__init__(*args, **kwargs)
self.fields['category'].queryset = categories_set
self.fields['author'].choices = authors_choices
class Meta:
model = Entry
exclude = ('blog', )
widgets = {
'publication_date': DateTimePicker,
'body': TinyMCELargeTable(attrs={
'cols': 80,
'rows': 15,
}),
'slug': SlugWidget('title'),
}
class ModelChoiceForm(forms.Form):
mod = forms.ModelChoiceField(queryset=SomeModel.objects.all())
class CourseSelectionForm(forms.Form):
course = forms.ModelChoiceField(queryset=Course.objects.filter(
marking_period__school_year__active_year=True).distinct(),
required=False)
class StudentGradeReportWriterForm(forms.Form):
date = forms.DateField(widget=adminwidgets.AdminDateWidget(),
initial=date.today,
validators=settings.DATE_VALIDATORS)
template = forms.ModelChoiceField(required=False,
queryset=Template.objects.all())
upload_template = forms.FileField(
required=False,
help_text="You may choose a template or upload one here")
include_deleted = forms.BooleanField(required=False)
all_students = forms.BooleanField(
required=False, widget=forms.CheckboxInput(attrs={'onclick': ''}))
student = AutoCompleteSelectMultipleField('student', required=False)
sort_by = forms.ChoiceField(choices=(('last_name', 'Student last name'),
('year', 'School year'),
('cohort', 'Primary Cohort')),
initial=1)
filter_year = forms.ModelMultipleChoiceField(
required=False, queryset=GradeLevel.objects.all())
filter_cohort = forms.ModelMultipleChoiceField(
required=False, queryset=Cohort.objects.all())
omit_substitutions = forms.BooleanField(
required=False
) # benchmark_grade only; displayed conditionally in template
def clean(self):
data = super(StudentGradeReportWriterForm, self).clean()
if not data.get('student') and not data.get('all_students'):
raise forms.ValidationError(
"You must either check \"all students\" or select a student")
if not data.get('template') and not data.get('upload_template'):
raise forms.ValidationError(
"You must either select a template or upload one.")
return data
def get_students(self, options, worker=False):
""" Returns all students based on criteria. data should be form.cleaned_data """
if worker:
from ecwsp.work_study.models import StudentWorker
students = StudentWorker.objects.all()
else:
students = Student.objects.all()
# if selecting individual students, don't filter out deleted
# why? Because it's unintuitive to pick one student, forgot about "include
# deleted" and hit go to recieve a blank sheet.
if not options['all_students']:
students = students.filter(id__in=options['student'])
elif not options['include_deleted']:
students = students.filter(is_active=True)
if options['student'].count == 1:
data['student'] = options['student'][0]
if options['sort_by'] == "year":
students = students.order_by('year', 'last_name', 'first_name')
elif options['sort_by'] == "hoomroom":
pass
if options['filter_year']:
students = students.filter(year__in=options['filter_year'])
if options['filter_cohort']:
students = students.filter(cohorts__in=options['filter_cohort'])
return students
class ModelChoiceForm(forms.Form):
mod = forms.ModelChoiceField(queryset=queryset)
class YearSelectForm(forms.Form):
school_year = forms.ModelChoiceField(queryset=SchoolYear.objects.all())
class UserForm(Form):
username = forms.CharField(
label=_("Username"),
help_text=
_("Username is name under which user is known to other users. Between 3 and 15 characters, only letters and digits are allowed."
),
max_length=255)
title = forms.CharField(
label=_("User Title"),
help_text=_("To override user title with custom one, enter it here."),
max_length=255,
required=False)
rank = forms.ModelChoiceField(
label=_("User Rank"),
help_text=_("This user rank."),
queryset=Rank.objects.order_by('order').all(),
required=False,
empty_label=_('No rank assigned'))
roles = False
email = forms.EmailField(label=_("E-mail Address"),
help_text=_("Member e-mail address."),
max_length=255)
new_password = forms.CharField(
label=_("Change User Password"),
help_text=
_("If you wish to change user password, enter here new password. Otherwhise leave this field blank."
),
max_length=255,
required=False,
widget=forms.PasswordInput)
avatar_custom = forms.CharField(
label=_("Set Non-Standard Avatar"),
help_text=
_("You can make this member use special avatar by entering name of image file located in avatars directory here."
),
max_length=255,
required=False)
avatar_ban = forms.BooleanField(
label=_("Lock Member's Avatar"),
help_text=
_("If you set this field to yes, this member's avatar will be deleted and replaced with random one selected from _removed gallery and member will not be able to change his avatar."
),
widget=YesNoSwitch,
required=False)
avatar_ban_reason_user = forms.CharField(
label=_("User-visible reason for lock"),
help_text=
_("You can leave message to member explaining why he or she is unable to change his avatar anymore. This message will be displayed to member in his control panel."
),
widget=forms.Textarea,
required=False)
avatar_ban_reason_admin = forms.CharField(
label=_("Forum Team-visible reason for lock"),
help_text=
_("You can leave message to other forum team members exmplaining why this member's avatar has been locked."
),
widget=forms.Textarea,
required=False)
signature = forms.CharField(
label=_("Signature"),
help_text=_(
"Signature is short message attached at end of member's messages."
),
widget=forms.Textarea,
required=False)
signature_ban = forms.BooleanField(
label=_("Lock Member's Signature"),
help_text=
_("If you set this field to yes, this member will not be able to change his signature."
),
widget=YesNoSwitch,
required=False)
signature_ban_reason_user = forms.CharField(
label=_("User-visible reason for lock"),
help_text=
_("You can leave message to member explaining why he or she is unable to edit his signature anymore. This message will be displayed to member in his control panel."
),
widget=forms.Textarea,
required=False)
signature_ban_reason_admin = forms.CharField(
label=_("Forum Team-visible reason for lock"),
help_text=
_("You can leave message to other forum team members exmplaining why this member's signature has been locked."
),
widget=forms.Textarea,
required=False)
def __init__(self, user=None, *args, **kwargs):
self.request = kwargs['request']
self.user = user
super(UserForm, self).__init__(*args, **kwargs)
def finalize_form(self):
# Roles list
if self.request.user.is_god():
self.add_field(
'roles',
forms.ModelMultipleChoiceField(
label=_("User Roles"),
help_text=_(
"This user roles. Roles are sets of user permissions"),
widget=forms.CheckboxSelectMultiple,
queryset=Role.objects.order_by('name').all(),
error_messages={
'required':
_("User must have at least one role assigned.")
}))
else:
self.add_field(
'roles',
forms.ModelMultipleChoiceField(
label=_("User Roles"),
help_text=_(
"This user roles. Roles are sets of user permissions"),
widget=forms.CheckboxSelectMultiple,
queryset=Role.objects.filter(
protected__exact=False).order_by('name').all(),
required=False))
# Keep non-gods from editing protected members sign-in credentials
if self.user.is_protected() and not self.request.user.is_god(
) and self.user.pk != self.request.user.pk:
del self.fields['email']
del self.fields['new_password']
def clean_username(self):
org_username = self.user.username
validate_username(self.cleaned_data['username'])
self.user.set_username(self.cleaned_data['username'])
try:
self.user.full_clean()
except ValidationError as e:
self.user.is_username_valid(e)
self.user.set_username(org_username)
return self.cleaned_data['username']
def clean_email(self):
self.user.set_email(self.cleaned_data['email'])
try:
self.user.full_clean()
except ValidationError as e:
self.user.is_email_valid(e)
return self.cleaned_data['email']
def clean_new_password(self):
if self.cleaned_data['new_password']:
validate_password(self.cleaned_data['new_password'])
self.user.set_password(self.cleaned_data['new_password'])
try:
self.user.full_clean()
except ValidationError as e:
self.user.is_password_valid(e)
return self.cleaned_data['new_password']
return ''
def clean_avatar_custom(self):
if self.cleaned_data['avatar_custom']:
try:
avatar_image = Image.open('%s/avatars/%s' %
(settings.STATICFILES_DIRS[0],
self.cleaned_data['avatar_custom']))
except IOError:
raise ValidationError(
_("Avatar does not exist or is not image file."))
return self.cleaned_data['avatar_custom']
return ''
class MarkingPeriodSelectForm(forms.Form):
marking_period = forms.ModelChoiceField(
queryset=MarkingPeriod.objects.filter(active=True))
class NewUserForm(Form):
username = forms.CharField(
label=_("Username"),
help_text=
_("Username is name under which user is known to other users. Between 3 and 15 characters, only letters and digits are allowed."
),
max_length=255)
title = forms.CharField(
label=_("User Title"),
help_text=_("To override user title with custom one, enter it here."),
max_length=255,
required=False)
rank = forms.ModelChoiceField(
label=_("User Rank"),
help_text=_("This user rank."),
queryset=Rank.objects.order_by('order').all(),
required=False,
empty_label=_('No rank assigned'))
roles = False
email = forms.EmailField(label=_("E-mail Address"),
help_text=_("Member e-mail address."),
max_length=255)
password = forms.CharField(label=_("User Password"),
help_text=_("Member password."),
max_length=255,
widget=forms.PasswordInput)
def finalize_form(self):
if self.request.user.is_god():
self.add_field(
'roles',
forms.ModelMultipleChoiceField(
label=_("User Roles"),
help_text=_(
"This user roles. Roles are sets of user permissions"),
widget=forms.CheckboxSelectMultiple,
queryset=Role.objects.order_by('name').all(),
error_messages={
'required':
_("User must have at least one role assigned.")
}))
else:
self.add_field(
'roles',
forms.ModelMultipleChoiceField(
label=_("User Roles"),
help_text=_(
"This user roles. Roles are sets of user permissions"),
widget=forms.CheckboxSelectMultiple,
queryset=Role.objects.filter(
protected__exact=False).order_by('name').all(),
required=False))
def clean_username(self):
validate_username(self.cleaned_data['username'])
new_user = User.objects.get_blank_user()
new_user.set_username(self.cleaned_data['username'])
try:
new_user.full_clean()
except ValidationError as e:
new_user.is_username_valid(e)
return self.cleaned_data['username']
def clean_email(self):
new_user = User.objects.get_blank_user()
new_user.set_email(self.cleaned_data['email'])
try:
new_user.full_clean()
except ValidationError as e:
new_user.is_email_valid(e)
return self.cleaned_data['email']
def clean_password(self):
new_user = User.objects.get_blank_user()
new_user.set_password(self.cleaned_data['password'])
try:
new_user.full_clean()
except ValidationError as e:
new_user.is_password_valid(e)
validate_password(self.cleaned_data['password'])
return self.cleaned_data['password']
class PageWAForm(ModuloModelForm):
app_page_type = forms.ModelChoiceField(queryset=ContentType.objects.filter(**LIMIT_CHOICES_TO),
empty_label=None)
default_template = forms.ChoiceField(label=_(u'template'),
help_text=_(u'Select the theme template for the page.'),
widget=TemplateThemeSelectWidget, required=False)
def __init__(self, *args, **kwargs):
super(PageWAForm, self).__init__(*args, **kwargs)
self.fields['app_page_type'].choices = content_type_choices(LIMIT_CHOICES_TO)
# Need to hide 'default_template' by default
hide_default_tpl_field = True
# Only if edition mode
if hasattr(self.instance, 'pk'):
if self.instance.pk:
# Add help_text
self.fields['app_page_type'].help_text = _(u"Be careful : if you change the app type, "
u"the current app will be deleted.")
# Hide the slug field if we edit the homepage
if self.instance.is_homepage:
self.fields['slug'].widget = forms.HiddenInput()
# Initialization of templates theme
theme_infos = themes_info(self.instance.website.theme.split('/')[0])[0]
if 'templates' in theme_infos:
# Theme has many templates
# we set the choices with those values
choices_default_templates = []
for template in theme_infos['templates']:
if template['file'] == settings.TEMPLATE_THEME_FILE_DEFAULT:
file_value = ""
else:
file_value = template['file']
choices_default_templates.append((
file_value,
({'title': template['title'], 'preview': template['preview']}),
))
self.fields['default_template'].choices = choices_default_templates
# We don't hide the field
hide_default_tpl_field = False
if hide_default_tpl_field:
# The theme defines only one template,
# so we hide the field and we add the current value of template page
# in choices to avoid error validation
self.fields['default_template'].choices = [(self.instance.default_template, '')]
self.fields['default_template'].widget = forms.HiddenInput()
def clean(self):
# Get the website
website = self.cleaned_data['website']
if 'slug' in self.cleaned_data:
slug = self.cleaned_data['slug']
else:
return self.cleaned_data
# Get the previous data to see if it was modified
if self.instance.id:
page = Page.objects.get(id = self.instance.id)
if page.slug == slug:
return self.cleaned_data
elif page.is_homepage:
errors_append(self, 'slug', _(u'You cannot change the homepage slug.'))
# The only empty slug page should be the home page.
if slug == "" and self.cleaned_data.get('parent', None) is not None:
errors_append(self, 'slug', _(u'A page without slug cannot have a parent'))
return self.cleaned_data
# Does this slug is already used ?
if Page.objects.filter(slug__exact=slug, website__exact=website, parent=self.cleaned_data.get('parent', None)).count() != 0:
errors_append(self, 'slug', _(u'This slug is already used by another page.'))
return self.cleaned_data
# Does the slug has the minimum size
if len(slug) > 0 and len(slug) < SLUG_MIN_SIZE:
errors_append(self, 'slug', _(u'A slug should be at least %(min_size)d characters long.') % {'min_size' : SLUG_MIN_SIZE})
return self.cleaned_data
# Parent should exist and should not be home
if self.cleaned_data.get('parent', None) is not None:
if self.cleaned_data['parent'].slug == "":
errors_append(self, 'parent', _(u'You cannot add a sub_page to the empty slug page.'))
return self.cleaned_data
class Meta:
model = Page
fields = ('website',
'parent',
'title',
'slug',
'draft',
'app_page_type',
'is_diplayed_in_menu',
'menu_title',
'meta_keywords',
'meta_description',
'default_template')
widgets = {
'meta_description': forms.Textarea(attrs={'cols': 40, 'rows': 5}),
'website': forms.HiddenInput(),
'slug': SlugWidget('title'),
'parent': forms.HiddenInput(attrs={'value': ""}),
}
class StepsForm(forms.Form):
activities = forms.ModelChoiceField(queryset=Activity.objects.filter(
team=team))
position = forms.IntegerField(required=False)
