Jens Kleineheismann
d7e2acff34
ugettext and ugettext_lazy were deprecated in Django 3 and will be removed in Django 4.
1082 lines
60 KiB
Python
1082 lines
60 KiB
Python
# -*- coding: utf-8 -*-
|
|
import calendar
|
|
import datetime
|
|
import logging
|
|
import re
|
|
from babel.dates import format_date
|
|
from django import forms
|
|
from django.apps import apps
|
|
from django.utils.translation import get_language, gettext, gettext_lazy as _
|
|
from django_countries.fields import Country, LazyTypedChoiceField
|
|
from datetimewidget.widgets import DateWidget, TimeWidget, DateTimeWidget
|
|
from six import string_types
|
|
|
|
from .. import choices
|
|
from .. import config
|
|
from .. import models
|
|
from ..workflow import DefaultWorkflow
|
|
from .generic import ChainedForm, ModelMixin
|
|
|
|
app_config = apps.get_containing_app_config(__package__)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class EventListExportForm(forms.Form):
|
|
sport = forms.MultipleChoiceField(choices=choices.SPORT_CHOICES,
|
|
required=False,
|
|
label=_(u'Spielart'),
|
|
initial=[c for c, l in choices.SPORT_CHOICES],
|
|
widget=forms.CheckboxSelectMultiple(),
|
|
)
|
|
begin = forms.DateField(required=False,
|
|
initial=datetime.date.today(),
|
|
label=_(u'Zeitraum - Start'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj'),
|
|
_(u'Kann frei gelassen werden'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_begin_widget',
|
|
'placeholder': _(u'Kann freigelassen werden')},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'startView': 3,
|
|
'clearBtn': True,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
end = forms.DateField(required=False,
|
|
label=_(u'Zeitraum - Ende'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj'),
|
|
_(u'Kann frei gelassen werden'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_end_widget',
|
|
'placeholder': _(u'Kann freigelassen werden')},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'startView': 3,
|
|
'clearBtn': True,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
deadline = forms.DateField(required=False,
|
|
initial=datetime.date.today(),
|
|
label=_(u'Frühester Anmeldeschluss'),
|
|
help_text=u'%s - %s - %s' % (
|
|
_(u'Veranstaltungen ausschließen,'
|
|
u' deren Anmeldeschluss an dem gewählten Datum bereits abgelaufen ist'),
|
|
_(u'Kann frei gelassen werden'),
|
|
_(u'Format: tt.mm.jjjj'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_deadline_widget',
|
|
'placeholder': _(u'Anmeldeschluss ignorieren'),
|
|
},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'startView': 3,
|
|
'clearBtn': True,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
|
|
class EventUpdateForm(forms.ModelForm):
|
|
requirements = forms.CharField(required=False,
|
|
label=_(u'Anforderungen / Voraussetzungen'),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
|
|
equipment = forms.CharField(required=False,
|
|
label=_(u'Ausrüstung'),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
|
|
registration_howto = forms.CharField(required=False,
|
|
label=_(u'Anmeldungshinweis'),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
|
|
course_topic_1 = forms.CharField(required=False,
|
|
label=u'%s - %s 1' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
course_topic_2 = forms.CharField(required=False,
|
|
label=u'%s - %s 2' % (_(u'Kursinhalt'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_topic_3 = forms.CharField(required=False,
|
|
label=u'%s - %s 3' % (_(u'Kursinhalt'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_topic_4 = forms.CharField(required=False,
|
|
label=u'%s - %s 4' % (_(u'Kursinhalt'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_topic_5 = forms.CharField(required=False,
|
|
label=u'%s - %s 5' % (_(u'Kursinhalt'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_topic_6 = forms.CharField(required=False,
|
|
label=u'%s - %s 6' % (_(u'Kursinhalt'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
|
|
course_goal_1 = forms.CharField(required=False,
|
|
label=u'%s - %s 1' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
course_goal_2 = forms.CharField(required=False,
|
|
label=u'%s - %s 2' % (_(u'Kursziel'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_goal_3 = forms.CharField(required=False,
|
|
label=u'%s - %s 3' % (_(u'Kursziel'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_goal_4 = forms.CharField(required=False,
|
|
label=u'%s - %s 4' % (_(u'Kursziel'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_goal_5 = forms.CharField(required=False,
|
|
label=u'%s - %s 5' % (_(u'Kursziel'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
course_goal_6 = forms.CharField(required=False,
|
|
label=u'%s - %s 6' % (_(u'Kursziel'), _(u'Zeile')),
|
|
widget=forms.TextInput())
|
|
|
|
description = forms.CharField(label=_(u'Beschreibung'),
|
|
widget=forms.Textarea(attrs={'rows': 5}))
|
|
|
|
internal_note = forms.CharField(required=False,
|
|
label=_(u'Bearbeitungshinweis'),
|
|
widget=forms.Textarea(attrs={'rows': 5}))
|
|
|
|
class Meta:
|
|
model = models.Event
|
|
fields = '__all__'
|
|
|
|
|
|
class EventCreateForm(ModelMixin, ChainedForm):
|
|
_model = models.Event
|
|
_initial_form_name = 'ModeForm'
|
|
|
|
def _serialize_value(self, value):
|
|
r = super(EventCreateForm, self)._serialize_value(value)
|
|
if isinstance(r, Country):
|
|
r = r.code
|
|
return r
|
|
|
|
def _get_instance_kwargs(self):
|
|
kwargs = self._session_data.copy()
|
|
if 'deadline' in kwargs:
|
|
buf = kwargs['deadline']
|
|
if isinstance(buf, string_types):
|
|
deadline_choice = buf.lower()
|
|
deadline_field = 'deadline_{}'.format(deadline_choice)
|
|
if deadline_field in kwargs:
|
|
kwargs['deadline'] = kwargs[deadline_field]
|
|
return kwargs
|
|
|
|
def _get_matrix_config(self, session_data):
|
|
mode = session_data.get('mode', None)
|
|
sport = session_data.get('sport', None)
|
|
ski_lift = session_data.get('ski_lift', False)
|
|
terrain = session_data.get('terrain', None)
|
|
country = session_data.get('country', None)
|
|
overnight = bool(session_data.get('last_day', None))
|
|
|
|
if sport == 'S' and ski_lift:
|
|
matrix_key = 'K'
|
|
elif sport == 'W' and not overnight:
|
|
matrix_key = '0'
|
|
elif sport == 'W' and terrain != 'alpine':
|
|
matrix_key = 'A'
|
|
elif sport == 'W':
|
|
matrix_key = 'B'
|
|
elif terrain != 'alpine' and not overnight:
|
|
matrix_key = 'C'
|
|
elif terrain != 'alpine':
|
|
matrix_key = 'D'
|
|
elif mode == 'training' and country in ('DE', 'AT'):
|
|
matrix_key = 'G'
|
|
elif mode == 'training':
|
|
matrix_key = 'H'
|
|
elif sport == 'K' and country in ('DE', 'AT'):
|
|
matrix_key = 'E'
|
|
elif sport == 'K':
|
|
matrix_key = 'F'
|
|
elif country in ('DE', 'AT'):
|
|
matrix_key = 'I'
|
|
else:
|
|
matrix_key = 'J'
|
|
|
|
return matrix_key, app_config.settings.matrix_config[matrix_key]
|
|
|
|
|
|
class ModeForm(EventCreateForm):
|
|
_form_title = _(u'Veranstaltungsmodus')
|
|
_next_form_name = 'LocationForm'
|
|
|
|
mode = forms.ChoiceField(choices=choices.MODE_CHOICES,
|
|
label=_(u'Veranstaltungsart'),
|
|
widget=forms.RadioSelect())
|
|
|
|
sport = forms.ChoiceField(choices=choices.SPORT_CHOICES,
|
|
label=_(u'Spielart'),
|
|
widget=forms.RadioSelect())
|
|
|
|
ski_lift = forms.BooleanField(required=False,
|
|
label=_(u'Skiliftbenutzung'),
|
|
help_text=u'%s %s' % (
|
|
_(u'Relevant für die Kostenberechnung bei Skitouren/-kursen.'),
|
|
_(u'Wird nicht veröffentlicht.'),
|
|
),
|
|
)
|
|
|
|
level = forms.ChoiceField(choices=choices.LEVEL_CHOICES,
|
|
label=_(u'Schwierigkeitsniveau / Familien'),
|
|
widget=forms.RadioSelect())
|
|
|
|
first_day = forms.DateField(required=True,
|
|
label=_(u'Erster Tag'),
|
|
help_text=_(u'Format: tt.mm.jjjj'),
|
|
widget=DateWidget(attrs={'id': 'id_first_day_widget'},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'clearBtn': False,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
last_day = forms.DateField(required=False,
|
|
label=_(u'Letzter Tag'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj'),
|
|
_(u'Bei Tagestouren frei lassen'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_last_day_widget',
|
|
'placeholder': _(u'Bei Tagestouren freilassen'),
|
|
},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
alt_first_day = forms.DateField(required=False,
|
|
label=u'%s - %s' % (_(u'Ersatztermin'), _(u'Erster Tag')),
|
|
help_text=u'%s - %s - %s' % (
|
|
_(u'Ausweichtermin bei unpassenden Bedingungen'),
|
|
_(u'Format: tt.mm.jjjj'),
|
|
_(u'Kann frei gelassen werden'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_alt_first_day_widget',
|
|
'placeholder': _(u'Kann frei gelassen werden'),
|
|
},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'clearBtn': False,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
alt_last_day = forms.DateField(required=False,
|
|
label=u'%s - %s' % (_(u'Ersatztermin'), _(u'Letzter Tag')),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj'),
|
|
_(u'Bei Tagestouren frei lassen'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_alt_last_day_widget',
|
|
'placeholder': _(u'Bei Tagestouren freilassen'),
|
|
},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
def clean(self):
|
|
cleaned_data = super(ModeForm, self).clean()
|
|
last_day = cleaned_data.get('last_day', None)
|
|
if last_day and last_day == cleaned_data.get('first_day', None):
|
|
cleaned_data['last_day'] = ''
|
|
alt_last_day = cleaned_data.get('alt_last_day', None)
|
|
if alt_last_day and alt_last_day == cleaned_data.get('alt_first_day', None):
|
|
cleaned_data['alt_last_day'] = ''
|
|
return cleaned_data
|
|
|
|
|
|
class LocationForm(EventCreateForm):
|
|
_form_title = _(u'Ort')
|
|
_next_form_name = 'JourneyForm'
|
|
|
|
country = LazyTypedChoiceField(choices=choices.COUNTRY_CHOICES,
|
|
label=_(u'Land'))
|
|
|
|
terrain = forms.ChoiceField(choices=choices.TERRAIN_CHOICES,
|
|
label=_(u'Gelände'),
|
|
help_text=u'%s %s' % (
|
|
_(u'Relevant für die Vorauswahl weiterer Felder.'),
|
|
_(u'Wird nicht veröffentlicht.'),
|
|
),
|
|
)
|
|
|
|
location = forms.CharField(required=False,
|
|
max_length=config.LOCATION_MAX_LENGTH,
|
|
label=_(u'Ort oder Gebiet'),
|
|
help_text=u'%s %s' % (
|
|
_(u'Orts- und Fels- bzw. Bergname, evtl. auch Gebirgsgruppe bzw. Region,'
|
|
u' so dass man mindestens eine grobe Vorstellung bekommt,'
|
|
u' wo das ganze stattfindet.'),
|
|
_(u'Kann in Ausnahmefällen (z.B. Streckenwanderung) freigelassen werden.'),
|
|
),
|
|
widget=forms.TextInput(
|
|
attrs={'placeholder': _(u'Kann in Ausnahmefällen frei gelassen werden')}
|
|
))
|
|
|
|
transport = forms.ChoiceField(choices=choices.TRANSPORT_CHOICES,
|
|
label=_(u'Verkehrsmittel zur An- und Abreise'),
|
|
)
|
|
transport_other = forms.CharField(required=False,
|
|
max_length=config.TRANSPORT_OTHER_MAX_LENGTH,
|
|
label=_(u'Anderes Verkehrsmittel zur An- und Abreise'),
|
|
)
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(LocationForm, self).proceed_session_data(session_data)
|
|
|
|
sport = session_data.get('sport', None)
|
|
last_day = session_data.get('last_day', None)
|
|
if sport == 'B':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Chamonix, Mont-Blanc-Gruppe'
|
|
elif sport == 'K':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Battert, Baden-Baden'
|
|
elif sport == 'M':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Pfälzerwald'
|
|
elif sport == 'S' and last_day:
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Obergurgl, Ötztaler Alpen'
|
|
elif sport == 'S':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Todtnau, Schwarzwald'
|
|
elif sport == 'W' and last_day:
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Ötztaler Alpen'
|
|
elif sport == 'W':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'z.B. Maikammer, Pfalz'
|
|
|
|
self.fields['transport_other'].widget.attrs['placeholder'] = _(u'Nebenstehendes Feld beachten')
|
|
|
|
|
|
class JourneyForm(EventCreateForm):
|
|
_form_title = _(u'An- und Abreise - Teil 2')
|
|
_next_form_name = 'RequirementsForm'
|
|
|
|
meeting_point = forms.ChoiceField(choices=choices.MEETING_POINT_CHOICES,
|
|
label=_(u'Treffpunkt'),
|
|
)
|
|
meeting_point_other = forms.CharField(required=False,
|
|
max_length=config.MEETING_POINT_OTHER_MAX_LENGTH,
|
|
label=_(u'Anderer Treffpunkt'),
|
|
)
|
|
|
|
meeting_time = forms.TimeField(required=False,
|
|
label=_(u'Uhrzeit am Treffpunkt'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: hh:mm'),
|
|
_(u'Kann freigelassen werden'),
|
|
),
|
|
widget=TimeWidget(attrs={'id': 'id_meeting_time_widget',
|
|
'placeholder': _(u'Kann freigelassen werden'),
|
|
},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'hh:ii',
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
departure_time = forms.TimeField(required=False,
|
|
label=_(u'Uhrzeit Abfahrt'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: hh:mm'),
|
|
_(u'Kann freigelassen werden'),
|
|
),
|
|
widget=TimeWidget(attrs={'id': 'id_departure_time_widget',
|
|
'placeholder': _(u'Kann freigelassen werden'),
|
|
},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'hh:ii',
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
departure_ride = forms.CharField(required=False,
|
|
max_length=config.MEETING_POINT_OTHER_MAX_LENGTH,
|
|
label=_(u'Bahn- / Bus-Linie / evtl. Haltestelle'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Wo sollen die Teilnehmer einsteigen, wenn kein Treffpunkt ausgemacht ist'
|
|
u', oder jemand später zusteigen will'),
|
|
_(u'Kann freigelassen werden'),),
|
|
)
|
|
|
|
return_departure_time = forms.TimeField(required=False,
|
|
label=_(u'Uhrzeit Rückfahrt (Abfahrt am Tourenort)'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: hh:mm'),
|
|
_(u'Kann freigelassen werden'),
|
|
),
|
|
widget=TimeWidget(attrs={'id': 'id_return_departure_time_widget',
|
|
'placeholder': _(u'Kann freigelassen werden'),
|
|
},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'hh:ii',
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
return_arrival_time = forms.TimeField(required=False,
|
|
label=_(u'oder: Uhrzeit Rückkunft (Ankunft in Karlsruhe)'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: hh:mm'),
|
|
_(u'Kann freigelassen werden'),
|
|
),
|
|
widget=TimeWidget(attrs={'id': 'id_return_arrival_time_widget',
|
|
'placeholder': _(u'Kann freigelassen werden'),
|
|
},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'hh:ii',
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
arrival_previous_day = forms.BooleanField(required=False,
|
|
label=_(u'Anreise des Kurs-/Tourenleiters am Vortag'),
|
|
help_text=u'%s %s' % (
|
|
_(u'Relevant für die Kostenberechnung.'),
|
|
_(u'Wird nicht veröffentlicht.'),
|
|
),
|
|
)
|
|
|
|
@property
|
|
def next_form_name(self):
|
|
if bool(self._session_data.get('last_day', None)):
|
|
return 'AccommodationForm'
|
|
return super(JourneyForm, self).next_form_name
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(JourneyForm, self).proceed_session_data(session_data)
|
|
|
|
first_day = session_data.get('first_day', None)
|
|
last_day = session_data.get('last_day', None)
|
|
transport = session_data.get('transport', None)
|
|
|
|
self.fields['meeting_point_other'].widget.attrs['placeholder'] = _(u'Nebenstehendes Feld beachten')
|
|
self.fields['departure_ride'].widget.attrs['placeholder'] = _(u'z.B. Linie S81 nach Freudenstadt, Gleis 9')
|
|
|
|
self.fields['meeting_time'].widget.options['startDate'] = first_day.strftime('%Y-%m-%d 00:00:00')
|
|
self.fields['meeting_time'].widget.options['endDate'] = first_day.strftime('%Y-%m-%d 23:59:59')
|
|
self.fields['departure_time'].widget.options['startDate'] = first_day.strftime('%Y-%m-%d 00:00:00')
|
|
self.fields['departure_time'].widget.options['endDate'] = first_day.strftime('%Y-%m-%d 23:59:59')
|
|
|
|
return_day = last_day or first_day
|
|
self.fields['return_departure_time'].widget.options['startDate'] = return_day.strftime('%Y-%m-%d 00:00:00')
|
|
self.fields['return_departure_time'].widget.options['endDate'] = return_day.strftime('%Y-%m-%d 23:59:59')
|
|
self.fields['return_arrival_time'].widget.options['startDate'] = return_day.strftime('%Y-%m-%d 00:00:00')
|
|
self.fields['return_arrival_time'].widget.options['endDate'] = return_day.strftime('%Y-%m-%d 23:59:59')
|
|
|
|
if transport != 'public':
|
|
self.fields['departure_time'].widget = forms.HiddenInput()
|
|
self.fields['departure_ride'].widget = forms.HiddenInput()
|
|
|
|
|
|
class AccommodationForm(EventCreateForm):
|
|
_form_title = _(u'Unterkunft')
|
|
_next_form_name = 'RequirementsForm'
|
|
|
|
basecamp = forms.CharField(required=False,
|
|
max_length=config.BASECAMP_MAX_LENGTH,
|
|
label=_(u'Stützpunkt'),
|
|
help_text=_(u'z.B. Name der AV-Hütte oder des Campingplatzes'),
|
|
)
|
|
|
|
accommodation = forms.ChoiceField(choices=choices.ACCOMMODATION_CHOICES,
|
|
label=_(u'Unterkunft'),
|
|
)
|
|
accommodation_other = forms.CharField(required=False,
|
|
max_length=config.ACCOMMODATION_OTHER_MAX_LENGTH,
|
|
label=_(u'Andere Unterkunft'),
|
|
)
|
|
|
|
meals = forms.ChoiceField(choices=choices.MEALS_CHOICES,
|
|
label=_(u'Verpflegung'),
|
|
)
|
|
meals_other = forms.CharField(required=False,
|
|
max_length=config.MEALS_OTHER_MAX_LENGTH,
|
|
label=_(u'Andere Verpflegung'),
|
|
)
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(AccommodationForm, self).proceed_session_data(session_data)
|
|
self.fields['basecamp'].widget.attrs['placeholder'] = _(u'Kann freigelassen werden')
|
|
self.fields['accommodation_other'].widget.attrs['placeholder'] = _(u'Nebenstehendes Feld beachten')
|
|
self.fields['meals_other'].widget.attrs['placeholder'] = _(u'Nebenstehendes Feld beachten')
|
|
|
|
|
|
class RequirementsForm(EventCreateForm):
|
|
_form_title = _(u'Voraussetzungen / Vorbedingungen')
|
|
_next_form_name = 'TrainerForm'
|
|
|
|
requirements = forms.CharField(required=False,
|
|
label=_(u'Anforderungen / Voraussetzungen'),
|
|
help_text=u'%s %s' % (
|
|
_(u'Was müssen Teilnehmer bereits können.'),
|
|
_(u'Schwierigkeitsgrade in arabischen Ziffern.'
|
|
u' Einheiten: km, Hm, Stunden.'),
|
|
),
|
|
widget=forms.Textarea(attrs={'rows': 2,
|
|
'placeholder': _(u'Kann frei gelassen werden')}))
|
|
|
|
equipment = forms.CharField(required=False,
|
|
label=_(u'Ausrüstung'),
|
|
help_text=u'%s %s' % (
|
|
_(u'Was müssen Teilnehmer mitbringen.'),
|
|
_(u'Diese Liste muss nicht vollständig sein,'
|
|
u' der potenzielle Teilnehmer soll aber ein Vorstellung davon bekommen,'
|
|
u' was er sich gegebenenfalls noch leihen/beschaffen muss.'),
|
|
),
|
|
widget=forms.Textarea(attrs={'rows': 2,
|
|
'placeholder': _(u'Kann frei gelassen werden')}))
|
|
|
|
pre_meeting_1 = forms.DateTimeField(required=False,
|
|
label=u'1. %s' % _(u'Vortreffen'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj hh:mm'),
|
|
_(u'Kann frei gelassen werden'),
|
|
),
|
|
widget=DateTimeWidget(attrs={'id': 'id_pre_meeting_1_widget',
|
|
'placeholder': _(u'Kann frei gelassen werden')},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'dd.mm.yyyy hh:ii',
|
|
'weekStart': 1,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
pre_meeting_2 = forms.DateTimeField(required=False,
|
|
label=u'2. %s' % _(u'Vortreffen'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj hh:mm'),
|
|
_(u'Kann frei gelassen werden'),
|
|
),
|
|
widget=DateTimeWidget(attrs={'id': 'id_pre_meeting_2_widget',
|
|
'placeholder': _(u'Kann frei gelassen werden')},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'dd.mm.yyyy hh:ii',
|
|
'weekStart': 1,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
|
|
class TrainerForm(EventCreateForm):
|
|
_form_title = _(u'Tourenleitung')
|
|
_next_form_name = 'RegistrationForm'
|
|
|
|
trainer_firstname = forms.CharField(label=_(u'Vorname'),
|
|
max_length=config.TRAINER_NAME_MAX_LENGTH)
|
|
trainer_familyname = forms.CharField(label=_(u'Familienname'),
|
|
max_length=config.TRAINER_NAME_MAX_LENGTH)
|
|
trainer_email = forms.EmailField(required=False,
|
|
label=_(u'E-Mail-Adresse'),
|
|
)
|
|
trainer_phone = forms.CharField(required=False,
|
|
max_length=config.PHONE_NUMBER_MAX_LENGTH,
|
|
label=_(u'Telefonnummer'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
|
|
trainer_2_fullname = forms.CharField(required=False,
|
|
max_length=config.TRAINER_NAME_MAX_LENGTH,
|
|
label=_(u'Name'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
trainer_2_email = forms.EmailField(required=False,
|
|
label=_(u'E-Mail-Adresse'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
trainer_2_phone = forms.CharField(required=False,
|
|
max_length=config.PHONE_NUMBER_MAX_LENGTH,
|
|
label=_(u'Telefonnummer'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
|
|
trainer_3_fullname = forms.CharField(required=False,
|
|
max_length=config.TRAINER_NAME_MAX_LENGTH,
|
|
label=_(u'Name'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
trainer_3_email = forms.EmailField(required=False,
|
|
label=_(u'E-Mail-Adresse'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
trainer_3_phone = forms.CharField(required=False,
|
|
max_length=config.PHONE_NUMBER_MAX_LENGTH,
|
|
label=_(u'Telefonnummer'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(TrainerForm, self).proceed_session_data(session_data)
|
|
|
|
self.fields['trainer_firstname'].widget.attrs['placeholder'] = _(u'Vorname')
|
|
self.fields['trainer_familyname'].widget.attrs['placeholder'] = _(u'Nachname')
|
|
self.fields['trainer_email'].widget.attrs['placeholder'] = _(u'E-Mail-Adresse')
|
|
self.fields['trainer_phone'].widget.attrs['placeholder'] = _(u'z.B. 0150 150 15 01')
|
|
self.fields['trainer_2_fullname'].widget.attrs['placeholder'] = _(u'Kann freigelassen werden')
|
|
self.fields['trainer_2_email'].widget.attrs['placeholder'] = u'--'
|
|
self.fields['trainer_2_phone'].widget.attrs['placeholder'] = u'--'
|
|
self.fields['trainer_3_fullname'].widget.attrs['placeholder'] = _(u'Kann freigelassen werden')
|
|
self.fields['trainer_3_email'].widget.attrs['placeholder'] = u'--'
|
|
self.fields['trainer_3_phone'].widget.attrs['placeholder'] = u'--'
|
|
|
|
if hasattr(self._request, 'user') and self._request.user.is_authenticated:
|
|
self.fields['trainer_firstname'].initial = self._request.user.first_name
|
|
self.fields['trainer_familyname'].initial = self._request.user.last_name
|
|
self.fields['trainer_email'].initial = self._request.user.email
|
|
elif app_config.settings.forms_development_init:
|
|
self.fields['trainer_firstname'].initial = _(u'Jens')
|
|
self.fields['trainer_familyname'].initial = _(u'Kleineheismann')
|
|
self.fields['trainer_email'].initial = _(u'heinzel@alpenverein-karlsruhe.de')
|
|
|
|
def clean_trainer_phone(self):
|
|
return re.sub(r'[-./]', ' ', self.cleaned_data['trainer_phone'])
|
|
|
|
def clean(self):
|
|
super(TrainerForm, self).clean()
|
|
trainer_email = self.cleaned_data.get('trainer_email', None)
|
|
trainer_phone = self.cleaned_data.get('trainer_phone', None)
|
|
if not trainer_email and not trainer_phone:
|
|
error_msg = _(u'Bitte E-Mail-Adresse und/oder Telefonnummer angeben.')
|
|
self.add_error('trainer_email', error_msg)
|
|
self.add_error('trainer_phone', error_msg)
|
|
raise forms.ValidationError(error_msg)
|
|
return self.cleaned_data
|
|
|
|
|
|
class RegistrationForm(EventCreateForm):
|
|
_form_title = _(u'Teilnehmer / Anmeldung')
|
|
_next_form_name = 'ChargesForm'
|
|
|
|
min_participants = forms.IntegerField(min_value=0,
|
|
label=_(u'Min. Teilnehmer'))
|
|
max_participants = forms.IntegerField(min_value=0,
|
|
label=_(u'Max. Teilnehmer'))
|
|
|
|
registration_required = forms.BooleanField(required=False,
|
|
label=_(u'Anmeldung notwendig'),
|
|
)
|
|
|
|
deadline = forms.ChoiceField(choices=choices.DEADLINE_CHOICES,
|
|
label=_(u'Anmeldeschluss'),
|
|
widget=forms.RadioSelect())
|
|
|
|
deadline_month = forms.DateField(widget=forms.HiddenInput())
|
|
deadline_quarter = forms.DateField(widget=forms.HiddenInput())
|
|
|
|
deadline_other = forms.DateField(required=False,
|
|
label=_(u'Anderer Anmeldeschluss'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: tt.mm.jjjj'),
|
|
_(u'Kann freigelassen werden'),
|
|
),
|
|
widget=DateWidget(attrs={'id': 'id_deadline_other_widget',
|
|
'placeholder': _(u'Kann freigelassen werden'),
|
|
},
|
|
usel10n=True,
|
|
options={
|
|
# 'format': 'dd.mm.yyyy',
|
|
# 'weekStart': 1,
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
registration_howto = forms.CharField(disabled=True,
|
|
required=False,
|
|
label=_(u'Anmeldungshinweis'),
|
|
help_text=_(u'Dieser Text kann absichtlich nicht geändert werden.'),
|
|
widget=forms.Textarea(attrs={'rows': 2}),
|
|
)
|
|
|
|
def get_initial_for_field(self, field, field_name):
|
|
value = super(RegistrationForm, self).get_initial_for_field(field, field_name)
|
|
if field_name == 'registration_howto' and value is not None:
|
|
trainer_firstname = self._session_data.get('trainer_firstname')
|
|
trainer_familyname = self._session_data.get('trainer_familyname')
|
|
trainer_email = self._session_data.get('trainer_email', None)
|
|
trainer_phone = self._session_data.get('trainer_phone', None)
|
|
if trainer_email:
|
|
trainer_contact = u'%s %s (%s)' % (trainer_firstname, trainer_familyname, trainer_email)
|
|
elif trainer_phone:
|
|
trainer_contact = u'%s %s (%s)' % (trainer_firstname, trainer_familyname, trainer_phone)
|
|
else:
|
|
trainer_contact = u'%s %s' % (trainer_firstname, trainer_familyname)
|
|
value %= {'trainer_contact': trainer_contact}
|
|
elif field_name in ('min_participants', 'max_participants') and value is None:
|
|
trainer_2 = bool(self._session_data.get('trainer_2_fullname', False))
|
|
trainer_3 = bool(self._session_data.get('trainer_3_fullname', False))
|
|
matrix_key, matrix_config = self._get_matrix_config(self._session_data)
|
|
n_trainer = 1
|
|
if trainer_2:
|
|
n_trainer += 1
|
|
if trainer_3:
|
|
n_trainer += 1
|
|
value = n_trainer * matrix_config[field_name]
|
|
elif field_name == 'deadline_month':
|
|
first_day = self._session_data.get('first_day')
|
|
m = first_day.month - 1 - 1
|
|
y = first_day.year + m // 12
|
|
m = m % 12 + 1
|
|
d = min(first_day.day, calendar.monthrange(y, m)[1])
|
|
date = datetime.date(y, m, d)
|
|
value = date.isoformat()
|
|
elif field_name == 'deadline_quarter':
|
|
first_day = self._session_data.get('first_day')
|
|
m = first_day.month - 1 - 3
|
|
y = first_day.year + m // 12
|
|
m = m % 12 + 1
|
|
d = min(first_day.day, calendar.monthrange(y, m)[1])
|
|
date = datetime.date(y, m, d)
|
|
value = date.isoformat()
|
|
|
|
return value
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(RegistrationForm, self).proceed_session_data(session_data)
|
|
|
|
new_choices = []
|
|
for key, desc in self.fields['deadline'].choices:
|
|
field_name = 'deadline_%s' % key
|
|
if field_name in self.fields:
|
|
date_str = self.get_initial_for_field(self.fields[field_name], field_name)
|
|
datetime_obj = datetime.datetime.strptime(date_str, '%Y-%m-%d')
|
|
date = datetime_obj.date()
|
|
desc += u' ({})'.format(format_date(date, 'EEEE, d. MMMM yyyy', locale=get_language()[0:2]))
|
|
new_choices.append((key, desc))
|
|
self.fields['deadline'].choices = new_choices
|
|
|
|
|
|
class ChargesForm(EventCreateForm):
|
|
_form_title = _(u'Kosten')
|
|
_next_form_name = 'DescriptionForm'
|
|
|
|
pubtrans_planned = forms.BooleanField(disabled=True, required=False,
|
|
label=_(u'An-/Abreise mit Bahn/Bus geplant'),
|
|
)
|
|
charge_key = forms.CharField(disabled=True,
|
|
label=_(u'Kostenschlüssel'),
|
|
)
|
|
orga_compensation = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwand für Tourenleitung'),
|
|
)
|
|
pubtrans_compensation = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwand für Organisation Bahn/Bus'),
|
|
)
|
|
trainer_compensation = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwand für Trainer*in'),
|
|
)
|
|
trainer_daily_compensation = forms.FloatField(disabled=True,
|
|
label=_(u'Täglicher Aufwand für Trainer*in'),
|
|
)
|
|
pre_meeting_compensation = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwand pro Vortreffen'),
|
|
)
|
|
participant_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Beitrag für Teilnehmer*in'),
|
|
)
|
|
participant_daily_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Täglicher Beitrag für Teilnehmer*in'),
|
|
)
|
|
pubtrans_bonus = forms.FloatField(disabled=True,
|
|
label=_(u'Rückzahlung bei Benutzung Bahn/Bus'),
|
|
)
|
|
trainer1_reward = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwandsentschädigung Tourenleiter*in'),
|
|
)
|
|
trainer23_reward = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwandsentschädigung Assistenz'),
|
|
)
|
|
|
|
charge = forms.FloatField(min_value=0,
|
|
label=_(u'Teilnahmegebühr in Euro'))
|
|
|
|
additional_costs = forms.CharField(required=False,
|
|
max_length=config.ADDITIONAL_COSTS_MAX_LENGTH,
|
|
label=_(u'Zusätzliche Kosten (Text)'),
|
|
help_text=_(u'Kann freigelassen werden'),
|
|
)
|
|
|
|
@property
|
|
def next_form_name(self):
|
|
if self._session_data.get('mode') == 'training':
|
|
return 'TrainingForm'
|
|
return super(ChargesForm, self).next_form_name
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(ChargesForm, self).proceed_session_data(session_data)
|
|
|
|
first_day = session_data.get('first_day', None)
|
|
arrival_previous_day = session_data.get('arrival_previous_day', False)
|
|
last_day = session_data.get('last_day', None)
|
|
transport = session_data.get('transport', None)
|
|
accommodation = session_data.get('accommodation', None)
|
|
pre_meeting_1 = session_data.get('pre_meeting_1', None)
|
|
pre_meeting_2 = session_data.get('pre_meeting_2', None)
|
|
|
|
matrix_key, matrix_config = self._get_matrix_config(session_data)
|
|
|
|
additional_costs_text = u''
|
|
if transport != 'coach':
|
|
additional_costs_text += gettext(u'Fahrtkosten')
|
|
if transport == 'public':
|
|
pubtrans_planned = True
|
|
else:
|
|
pubtrans_planned = False
|
|
|
|
if last_day:
|
|
timedelta = last_day - first_day
|
|
ndays = timedelta.days + 1
|
|
if accommodation != 'NONE':
|
|
if additional_costs_text:
|
|
additional_costs_text += u', '
|
|
additional_costs_text += gettext(u'Unterkunft und Verpflegung')
|
|
else:
|
|
ndays = 1
|
|
|
|
if pre_meeting_2:
|
|
n_pre_meetings = 2
|
|
elif pre_meeting_1:
|
|
n_pre_meetings = 1
|
|
else:
|
|
n_pre_meetings = 0
|
|
|
|
trainer1_reward = (
|
|
matrix_config['orga_compensation']
|
|
+ matrix_config['trainer_compensation']
|
|
+ ndays * matrix_config['trainer_daily_compensation']
|
|
+ n_pre_meetings * matrix_config['pre_meeting_compensation']
|
|
)
|
|
trainer23_reward = (
|
|
matrix_config['trainer_compensation']
|
|
+ ndays * matrix_config['trainer_daily_compensation']
|
|
+ n_pre_meetings * matrix_config['pre_meeting_compensation']
|
|
)
|
|
charge = (
|
|
matrix_config['participant_fee']
|
|
+ ndays * matrix_config['participant_daily_fee']
|
|
)
|
|
|
|
if pubtrans_planned:
|
|
trainer1_reward += matrix_config['pubtrans_compensation']
|
|
|
|
if arrival_previous_day:
|
|
trainer1_reward += matrix_config['trainer_daily_compensation'] / 2.0
|
|
trainer23_reward += matrix_config['trainer_daily_compensation'] / 2.0
|
|
charge += matrix_config['participant_daily_fee'] / 2.0
|
|
|
|
self.fields['pubtrans_planned'].initial = pubtrans_planned
|
|
self.fields['charge_key'].initial = matrix_config['description'] or matrix_key
|
|
self.fields['orga_compensation'].initial = matrix_config['orga_compensation']
|
|
self.fields['pubtrans_compensation'].initial = matrix_config['pubtrans_compensation']
|
|
self.fields['trainer_compensation'].initial = matrix_config['trainer_compensation']
|
|
self.fields['trainer_daily_compensation'].initial = matrix_config['trainer_daily_compensation']
|
|
self.fields['pre_meeting_compensation'].initial = matrix_config['pre_meeting_compensation']
|
|
self.fields['participant_fee'].initial = matrix_config['participant_fee']
|
|
self.fields['participant_daily_fee'].initial = matrix_config['participant_daily_fee']
|
|
self.fields['pubtrans_bonus'].initial = matrix_config['pubtrans_bonus']
|
|
self.fields['charge'].initial = charge
|
|
self.fields['trainer1_reward'].initial = trainer1_reward
|
|
self.fields['trainer23_reward'].initial = trainer23_reward
|
|
|
|
self.fields['pubtrans_bonus'].widget.attrs['title'] = gettext(u'Der Bonus wird nachträglich'
|
|
u' auf Meldung der Tourenleitung'
|
|
u' verrechnet und ist noch nicht'
|
|
u' in den hier dargestellten Zahlen enthalten.')
|
|
self.fields['charge'].widget.attrs['title'] = (u'%d € Beitrag \n'
|
|
u'+ %d Tage * %d € täglicher Beitrag \n'
|
|
u'+ %d halben Anreisetag * %d € halbtäglicher Beitrag'
|
|
% (
|
|
matrix_config['participant_fee'],
|
|
ndays, matrix_config['participant_daily_fee'],
|
|
int(arrival_previous_day), matrix_config['participant_daily_fee']/2,
|
|
)
|
|
)
|
|
self.fields['trainer1_reward'].widget.attrs['title'] = (u'%d € Aufwand für Tourenleitung\n'
|
|
u'+ %d € Aufwand für Organisation Bahn/Bus\n'
|
|
u'+ %d € Aufwand für Trainer*in\n'
|
|
u'+ %d Tage * %d € täglicher Aufwand \n'
|
|
u'+ %d halben Anreisetag * %d € halbtäglicher Aufwand\n'
|
|
u'+ %d Vortreffen * %d € Aufwand pro Vortreffen'
|
|
% (
|
|
matrix_config['orga_compensation'],
|
|
int(pubtrans_planned)*matrix_config['pubtrans_compensation'],
|
|
matrix_config['trainer_compensation'],
|
|
ndays, matrix_config['trainer_daily_compensation'],
|
|
int(arrival_previous_day), matrix_config['trainer_daily_compensation']/2,
|
|
n_pre_meetings, matrix_config['pre_meeting_compensation']
|
|
)
|
|
)
|
|
self.fields['trainer23_reward'].widget.attrs['title'] = (u'%d € Aufwand für Trainer*in\n'
|
|
u'+ %d Tage * %d € täglicher Aufwand \n'
|
|
u'+ %d halben Anreisetag * %d € halbtäglicher Aufwand\n'
|
|
u'+ %d Vortreffen * %d € Aufwand pro Vortreffen'
|
|
% (
|
|
matrix_config['trainer_compensation'],
|
|
ndays, matrix_config['trainer_daily_compensation'],
|
|
int(arrival_previous_day), matrix_config['trainer_daily_compensation']/2,
|
|
n_pre_meetings, matrix_config['pre_meeting_compensation']
|
|
)
|
|
)
|
|
|
|
self.fields['additional_costs'].widget.attrs['placeholder'] = gettext(u'Kann freigelassen werden')
|
|
self.fields['additional_costs'].initial = additional_costs_text
|
|
|
|
|
|
class TrainingForm(EventCreateForm):
|
|
_form_title = _(u'Kursinhalte / Kursziele')
|
|
_next_form_name = 'DescriptionForm'
|
|
|
|
course_topic_1 = forms.CharField(required=True,
|
|
label=u'%s - %s 1' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
course_topic_2 = forms.CharField(required=False,
|
|
label=u'%s - %s 2' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_topic_3 = forms.CharField(required=False,
|
|
label=u'%s - %s 3' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_topic_4 = forms.CharField(required=False,
|
|
label=u'%s - %s 4' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_topic_5 = forms.CharField(required=False,
|
|
label=u'%s - %s 5' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_topic_6 = forms.CharField(required=False,
|
|
label=u'%s - %s 6' % (_(u'Kursinhalt'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
|
|
course_goal_1 = forms.CharField(required=True,
|
|
label=u'%s - %s 1' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.Textarea(attrs={'rows': 2}))
|
|
course_goal_2 = forms.CharField(required=False,
|
|
label=u'%s - %s 2' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_goal_3 = forms.CharField(required=False,
|
|
label=u'%s - %s 3' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_goal_4 = forms.CharField(required=False,
|
|
label=u'%s - %s 4' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_goal_5 = forms.CharField(required=False,
|
|
label=u'%s - %s 5' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
course_goal_6 = forms.CharField(required=False,
|
|
label=u'%s - %s 6' % (_(u'Kursziel'), _(u'Absatz')),
|
|
widget=forms.TextInput(attrs={'placeholder': _(u'Kann frei gelassen werden')}))
|
|
|
|
|
|
class DescriptionForm(EventCreateForm):
|
|
_form_title = _(u'Titel / Beschreibung')
|
|
_next_form_name = 'SummaryForm'
|
|
|
|
title = forms.CharField(max_length=config.TITLE_MAX_LENGTH,
|
|
label=_(u'Name bzw. Titel der Veranstaltung'),
|
|
)
|
|
description = forms.CharField(label=_(u'Beschreibung'),
|
|
widget=forms.Textarea(attrs={'rows': 5}))
|
|
|
|
def get_initial_for_field(self, field, field_name):
|
|
value = super(DescriptionForm, self).get_initial_for_field(field, field_name)
|
|
if field_name == 'title' and value is None:
|
|
mode = self._session_data.get('mode', None)
|
|
sport = self._session_data.get('sport', None)
|
|
level = self._session_data.get('level', None)
|
|
terrain = self._session_data.get('terrain', None)
|
|
last_day = self._session_data.get('last_day', None)
|
|
|
|
value = u''
|
|
if mode == 'training':
|
|
# Titelprefix für Kurse
|
|
if level == 'family':
|
|
value += u'%s' % gettext(u'Familienkurs')
|
|
elif level == 'beginner':
|
|
value += u'%s' % gettext(u'Grundkurs')
|
|
else:
|
|
value += u'%s' % gettext(u'Aufbaukurs')
|
|
|
|
if sport == 'B':
|
|
value += u' %s' % gettext(u'Alpin')
|
|
elif sport == 'K':
|
|
if terrain == 'gym':
|
|
value += u' %s' % gettext(u'Indoorklettern')
|
|
elif terrain == 'crag':
|
|
value += u' %s' % gettext(u'Fels')
|
|
elif terrain == 'alpine':
|
|
value += u' %s' % gettext(u'Alpinklettern')
|
|
|
|
value += u': ...'
|
|
elif sport == 'W':
|
|
# Titelprefix für Wanderungen
|
|
if level == 'family':
|
|
value += u'%s ...' % gettext(u'Familienwanderung')
|
|
elif not last_day:
|
|
value += u'%s ...' % gettext(u'Tageswanderung')
|
|
elif level == 'family':
|
|
# Titelprefix für sonstige Familientouren
|
|
value += u'%s: ...' % gettext(u'Familientour')
|
|
|
|
if app_config.settings.forms_development_init:
|
|
if not value:
|
|
value += u'%s' % choices.SPORT_CHOICES.get_label(sport)
|
|
|
|
return value
|
|
|
|
|
|
class SummaryForm(EventCreateForm):
|
|
_form_title = _(u'Zusammenfassung')
|
|
|
|
planned_publication_date = forms.DateField(required=False,
|
|
label=_(u'Voraussichtliche Veröffentlichung'),
|
|
widget=forms.HiddenInput())
|
|
planned_publication_issue = forms.CharField(required=False)
|
|
|
|
internal_note = forms.CharField(required=False,
|
|
label=_(u'Bearbeitungshinweis'),
|
|
help_text=_(u'Hier kannst du einen Hinweis'
|
|
u' für Tourenreferenten und Redakteure eingeben.'),
|
|
widget=forms.Textarea(attrs={'rows': 5}))
|
|
|
|
def proceed_session_data(self, session_data):
|
|
super(SummaryForm, self).proceed_session_data(session_data)
|
|
|
|
registration_required = self._session_data.get('registration_required', False)
|
|
if registration_required:
|
|
deadline = self._session_data.get('deadline', None)
|
|
if deadline == 'OTHER':
|
|
deadline = self._session_data.get('deadline_other', None)
|
|
else:
|
|
deadline_field_name = 'deadline_%s' % deadline
|
|
if deadline_field_name in self._session_data:
|
|
deadline = self._session_data.get(deadline_field_name)
|
|
else:
|
|
logger.error('SummaryForm.proceed_session_data(): invalid value for deadline.')
|
|
deadline = None
|
|
|
|
first_day = self._session_data.get('first_day')
|
|
issue_date, issue = DefaultWorkflow.plan_publication(first_day, deadline)
|
|
if issue_date:
|
|
self.fields['planned_publication_date'].initial = issue_date
|
|
self.fields['planned_publication_issue'].initial = issue |