885 lines
44 KiB
Python
885 lines
44 KiB
Python
# -*- coding: utf-8 -*-
|
|
import calendar
|
|
import datetime
|
|
import logging
|
|
from babel.dates import format_date
|
|
from django import forms
|
|
from django.contrib.auth import forms as auth_forms, password_validation
|
|
from django.core.exceptions import ImproperlyConfigured
|
|
from django.utils.translation import get_language, ugettext, ugettext_lazy as _
|
|
from django_countries.fields import LazyTypedChoiceField
|
|
from datetimewidget.widgets import DateWidget, TimeWidget, DateTimeWidget
|
|
|
|
from . import choices
|
|
from . import config
|
|
from . import converters
|
|
from . import models
|
|
|
|
logger = logging.getLogger(__name__)
|
|
DEVELOPMENT_INIT_FORMS = True
|
|
|
|
|
|
class LoginForm(auth_forms.AuthenticationForm):
|
|
username = auth_forms.UsernameField(
|
|
max_length=254,
|
|
label=_(u'E-Mail-Adresse'),
|
|
widget=forms.TextInput(attrs={'autofocus': True}),
|
|
)
|
|
|
|
error_messages = {
|
|
'invalid_login': _(u'Benutzername oder Passwort falsch.'),
|
|
'inactive': _("This account is inactive."),
|
|
}
|
|
|
|
def clean_username(self):
|
|
username = self.cleaned_data.get('username')
|
|
return username.lower()
|
|
|
|
|
|
class SetPasswordForm(forms.Form):
|
|
new_password = forms.CharField(max_length=12,
|
|
label=_(u'Neues Passwort'),
|
|
widget=forms.PasswordInput)
|
|
new_password_repeat = forms.CharField(max_length=12,
|
|
label=_(u'Neues Passwort wiederholen'),
|
|
widget=forms.PasswordInput)
|
|
send_password_mail = forms.BooleanField(required=False,
|
|
label=_(u'Neues Passwort per E-Mail zusenden'),
|
|
)
|
|
|
|
def __init__(self, user, *args, **kwargs):
|
|
self.user = user
|
|
super(SetPasswordForm, self).__init__(*args, **kwargs)
|
|
|
|
def clean_new_password(self):
|
|
password = self.cleaned_data.get('new_password')
|
|
password_validation.validate_password(password, self.user)
|
|
return password
|
|
|
|
def clean_new_password_repeat(self):
|
|
password1 = self.cleaned_data.get('new_password')
|
|
password2 = self.cleaned_data.get('new_password_repeat')
|
|
if password1 and password2:
|
|
if password1 != password2:
|
|
raise forms.ValidationError(
|
|
ugettext(u'Passwörter stimmen nicht überein'),
|
|
code='password_mismatch',
|
|
)
|
|
return password2
|
|
|
|
def save(self, commit=True):
|
|
new_password = self.cleaned_data.get('new_password')
|
|
self.user.set_password(new_password)
|
|
if commit:
|
|
self.user.save()
|
|
return self.user
|
|
|
|
|
|
class ChainedForm(forms.Form):
|
|
_next_form_name = None
|
|
|
|
def __init__(self, *args, **kwargs):
|
|
self._session_data = dict()
|
|
self._request = kwargs.pop('request', None)
|
|
self._load_session_data()
|
|
|
|
super(ChainedForm, self).__init__(*args, **kwargs)
|
|
|
|
self._proceed_session_data(self._session_data)
|
|
|
|
def _serialize_value(self, value):
|
|
return converters.Iso8601Serializer.serialize(value, ignore_unsupported_input=True)
|
|
|
|
def _deserialize_value(self, value):
|
|
return converters.Iso8601Serializer.deserialize(value, ignore_unsupported_input=True)
|
|
|
|
def _load_session_data(self):
|
|
if self._request is not None and hasattr(self._request, 'session'):
|
|
session_var_name = '{}_chained_form_session_data'.format(self._request.resolver_match.url_name)
|
|
session_data = self._request.session.get(session_var_name, dict())
|
|
for k in session_data:
|
|
self._session_data[k] = self._deserialize_value(session_data[k])
|
|
|
|
def _save_session_data(self):
|
|
if self._request is not None and hasattr(self._request, 'session'):
|
|
session_var_name = '{}_chained_form_session_data'.format(self._request.resolver_match.url_name)
|
|
session_data = dict()
|
|
for k in self._session_data:
|
|
session_data[k] = self._serialize_value(self._session_data[k])
|
|
self._request.session[session_var_name] = session_data
|
|
|
|
def _proceed_session_data(self, session_data):
|
|
pass
|
|
|
|
def _get_model(self):
|
|
if not hasattr(self, '_model'):
|
|
raise ImproperlyConfigured('{cls} is missing a Model.'
|
|
' Define {cls}._model'.format(cls=self.__class__.__name__))
|
|
return self._model
|
|
|
|
def _get_object(self, model_kwargs):
|
|
return self._get_model()(**model_kwargs)
|
|
|
|
@property
|
|
def form_name(self):
|
|
return self.__class__.__name__
|
|
|
|
@property
|
|
def form_title(self):
|
|
if hasattr(self, '_form_title'):
|
|
return self._form_title
|
|
n = self.form_name
|
|
if n.endswith('Form'):
|
|
n = n[:-len('Form')]
|
|
return n
|
|
|
|
@property
|
|
def next_form_name(self):
|
|
return self._next_form_name
|
|
|
|
@classmethod
|
|
def get_form_name(cls):
|
|
return cls.__name__
|
|
|
|
@classmethod
|
|
def get_next_form_name(cls):
|
|
return cls._next_form_name
|
|
|
|
def clean(self):
|
|
cleaned_data = super(ChainedForm, self).clean()
|
|
self._session_data.update(cleaned_data)
|
|
self._save_session_data()
|
|
return cleaned_data
|
|
|
|
def save(self):
|
|
object_kwargs = dict()
|
|
data = self._session_data
|
|
if 'deadline' in data:
|
|
buf = data['deadline']
|
|
if isinstance(buf, basestring):
|
|
deadline_choice = buf.lower()
|
|
deadline_field = 'deadline_{}'.format(deadline_choice)
|
|
if deadline_field in data:
|
|
data['deadline'] = data[deadline_field]
|
|
|
|
model = self._get_model()
|
|
for field in data:
|
|
if hasattr(model, field):
|
|
object_kwargs[field] = data[field]
|
|
|
|
return self._get_object(object_kwargs)
|
|
|
|
|
|
class EventCreateForm(ChainedForm):
|
|
_model = models.Event
|
|
|
|
|
|
class ModeForm(EventCreateForm):
|
|
_form_title = _(u'Veranstaltungsmodus')
|
|
_next_form_name = 'LocationForm'
|
|
|
|
mode = forms.ChoiceField(choices=choices.MODE_CHOICES,
|
|
initial='joint',
|
|
label=_(u'Veranstaltungsart'),
|
|
widget=forms.RadioSelect())
|
|
|
|
sport = forms.ChoiceField(choices=choices.SPORT_CHOICES,
|
|
initial='W',
|
|
label=_(u'Spielart'),
|
|
widget=forms.RadioSelect())
|
|
|
|
ski_lift = forms.BooleanField(required=False,
|
|
label=_(u'Skiliftbenutzung'),
|
|
help_text=_(u'Relevant für die Kostenberechnung bei Skitouren/-kursen'),
|
|
)
|
|
|
|
level = forms.ChoiceField(choices=choices.LEVEL_CHOICES,
|
|
initial='beginner',
|
|
label=_(u'Schwierigkeitsnivau'),
|
|
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))
|
|
|
|
@property
|
|
def next_form_name(self):
|
|
if self.cleaned_data.get('mode') == 'training':
|
|
return 'TrainingForm'
|
|
return super(ModeForm, self).next_form_name
|
|
|
|
|
|
class TrainingForm(EventCreateForm):
|
|
_form_title = _(u'Kursinhalte / Kursziele')
|
|
_next_form_name = 'LocationForm'
|
|
|
|
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 LocationForm(EventCreateForm):
|
|
_form_title = _(u'Ort')
|
|
_next_form_name = 'ApproachForm'
|
|
|
|
country = LazyTypedChoiceField(choices=choices.COUNTRY_CHOICES,
|
|
initial='DE',
|
|
label=_(u'Land'))
|
|
|
|
terrain = forms.ChoiceField(choices=choices.TERRAIN_CHOICES,
|
|
initial='submountains',
|
|
label=_(u'Gelände'),
|
|
help_text=_(u'Relevant für die Vorauswahl weiterer Felder.'),
|
|
)
|
|
|
|
location = forms.CharField(max_length=config.LOCATION_MAX_LENGTH,
|
|
label=_(u'Ort'),
|
|
help_text=_(u'z.B. Orts- und Fels- bzw. Bergname, evtl. auch Region,'
|
|
u' so dass man mindestens eine grobe Vorstellung bekommt,'
|
|
u' wo das ganze stattfindet.'),
|
|
widget=forms.TextInput(attrs={'placeholder': u'Karlsruhe'}))
|
|
|
|
def _proceed_session_data(self, session_data):
|
|
super(LocationForm, self)._proceed_session_data(session_data)
|
|
|
|
sport = session_data.get('sport', None)
|
|
if sport == 'B':
|
|
self.fields['terrain'].initial = 'alpine'
|
|
self.fields['location'].widget.attrs['placeholder'] = u'Ramsau, Berchtesgadener Alpen'
|
|
elif sport == 'K':
|
|
self.fields['terrain'].initial = 'crag'
|
|
self.fields['location'].widget.attrs['placeholder'] = u'Battert, Baden-Baden'
|
|
elif sport == 'M':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'Pfälzerwald'
|
|
elif sport == 'S':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'Todtnau, Schwarzwald'
|
|
elif sport == 'W':
|
|
self.fields['location'].widget.attrs['placeholder'] = u'Maikammer, Pfalz'
|
|
|
|
if DEVELOPMENT_INIT_FORMS:
|
|
self.fields['location'].initial = self.fields['location'].widget.attrs['placeholder']
|
|
|
|
|
|
class ApproachForm(EventCreateForm):
|
|
_form_title = _(u'An- und Abreise / Unterkunft')
|
|
_next_form_name = 'RequirementsForm'
|
|
|
|
transport = forms.ChoiceField(choices=choices.TRANSPORT_CHOICES,
|
|
label=_(u'Verkehrsmittel'),
|
|
)
|
|
transport_other = forms.CharField(required=False,
|
|
max_length=config.TRANSPORT_OTHER_MAX_LENGTH,
|
|
label=_(u'Anderes Verkehrsmittel'),
|
|
)
|
|
|
|
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))
|
|
|
|
arrival_previous_day = forms.BooleanField(required=False,
|
|
label=_(u'Anreise am Vortag'),
|
|
help_text=_(u'Relevant für die Kostenberechnung'),
|
|
)
|
|
|
|
return_time = forms.TimeField(required=False,
|
|
label=_(u'Uhrzeit Rückkunft'),
|
|
help_text=u'%s - %s' % (
|
|
_(u'Format: hh:mm'),
|
|
_(u'Kann freigelassen werden')
|
|
),
|
|
widget=TimeWidget(attrs={'id': 'id_back_time_widget',
|
|
'placeholder': _(u'Kann freigelassen werden'),
|
|
},
|
|
# usel10n=True,
|
|
options={
|
|
'format': 'hh:ii',
|
|
'pickerPosition': 'bottom-left',
|
|
},
|
|
bootstrap_version=3))
|
|
|
|
basecamp = forms.CharField(required=False,
|
|
max_length=config.BASECAMP_MAX_LENGTH,
|
|
label=_(u'Stützpunkt'),
|
|
)
|
|
|
|
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,
|
|
initial='NONE',
|
|
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(ApproachForm, self)._proceed_session_data(session_data)
|
|
|
|
last_day = session_data.get('last_day', None)
|
|
sport = session_data.get('sport', None)
|
|
country = session_data.get('country', None)
|
|
terrain = session_data.get('terrain', None)
|
|
|
|
self.fields['transport_other'].widget.attrs['placeholder'] = _(u'Nebenstehendes Feld beachten')
|
|
self.fields['meeting_point_other'].widget.attrs['placeholder'] = _(u'Nebenstehendes Feld beachten')
|
|
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')
|
|
|
|
if terrain == 'alpine':
|
|
self.fields['accommodation'].initial = 'hut'
|
|
|
|
if sport in ('M', 'W'):
|
|
if country == 'DE' and terrain == 'submountains':
|
|
self.fields['transport'].initial = 'train'
|
|
self.fields['meeting_point'].initial = 'hbf'
|
|
|
|
if not last_day:
|
|
self.fields['basecamp'].widget = forms.HiddenInput()
|
|
self.fields['accommodation'].widget = forms.HiddenInput()
|
|
self.fields['accommodation'].required = False
|
|
self.fields['accommodation_other'].widget = forms.HiddenInput()
|
|
|
|
|
|
class RequirementsForm(EventCreateForm):
|
|
_form_title = _(u'Voraussetungen / Vorbedingungen')
|
|
_next_form_name = 'DescriptionForm'
|
|
|
|
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' 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 potentielle 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))
|
|
|
|
def _proceed_session_data(self, session_data):
|
|
super(RequirementsForm, self)._proceed_session_data(session_data)
|
|
|
|
sport = session_data.get('sport', None)
|
|
level = session_data.get('level', None)
|
|
terrain = session_data.get('terrain', None)
|
|
|
|
if sport == 'B':
|
|
self.fields['equipment'].initial = u'%s (%s)' % (
|
|
_(u'Steigeisen*, Pickel*, Klettergurt*, Steinschlaghelm*,'
|
|
u' Gletscherbrille, wasserfeste Kleidung, Gamaschen'),
|
|
_(u'* Ausrüstung kann ggf. von der Sektion geliehen werden')
|
|
)
|
|
|
|
if level == 'beginner':
|
|
self.fields['requirements'].initial = _(u'Kondition für ganztätige Aktivität im Freien'
|
|
u' mit Auf- und Abstiegen bis zu 1000 Hm.')
|
|
else:
|
|
self.fields['requirements'].initial = _(u'Sicheres Vorsteigen am Fels im 4. Grad UIAA.'
|
|
u' Grundkentnisse Hochtouren, Spaltenbergung.'
|
|
u' Kondition für Auf- und Abstiege bis zu 1300 Hm.')
|
|
elif sport == 'K':
|
|
self.fields['equipment'].initial = u'%s (%s)' % (
|
|
_(u'Kletterschuhe, Hüftgurt*, Steinschlaghelm*'),
|
|
_(u'* Ausrüstung kann ggf. von der Sektion geliehen werden')
|
|
)
|
|
if level == 'beginner':
|
|
self.fields['requirements'].initial = _(u'Sicheres Klettern im 4. Grad UIAA.'
|
|
u' Beherrschen der Sicherungstechnik.')
|
|
else:
|
|
self.fields['requirements'].initial = _(u'Sicheres Vorsteigen am Fels im 5. Grad UIAA.'
|
|
u' Beherrschen der Sicherungs- und Abseiltechnik.')
|
|
elif sport == 'M':
|
|
self.fields['equipment'].initial = _(u'Funktionstüchtiges MTB (bitte vorher überprüfen), Fahrrad-Helm'
|
|
u' und Radhandschuhe sind zwingend erforderlich,'
|
|
u' Brille und Protektoren empfehlenswert.'
|
|
u' Die Sattelstütze muss sich tief versenken lassen.')
|
|
if level == 'beginner':
|
|
self.fields['requirements'].initial = _(u'Kondition für Radtouren bis 30 km und 500 Hm'
|
|
u' in ca. 3 Stunden.')
|
|
else:
|
|
self.fields['requirements'].initial = _(u'Kondition für Radtouren bis 60 km und 1000 Hm'
|
|
u' in ca. 5 Stunden.'
|
|
u' Sicheres Beherrschen von Trails der Schwierigkeit S1.')
|
|
elif sport == 'S':
|
|
self.fields['equipment'].initial = u'%s (%s)' % (
|
|
_(u'Komplette Skitourenausrüstung inkl. Ski, Lawinen-Pieps*, Schaufel* und Sonde*'),
|
|
_(u'* Ausrüstung kann ggf. von der Sektion geliehen werden')
|
|
)
|
|
if level == 'beginner':
|
|
self.fields['requirements'].initial = _(u'Sicheres Skifahren und erste Erfahrungen abseits'
|
|
u' der gespurten Piste.')
|
|
else:
|
|
self.fields['requirements'].initial = _(u'Mittelschwere, lange Skitouren bis 1500 Hm.'
|
|
u' Solide Aufstiegs- und Abfahrtstechnik.')
|
|
elif sport == 'W':
|
|
if terrain == 'alpine':
|
|
self.fields['equipment'].initial = _(u'Feste, knöchelhohe Wanderschuhe, Regenschutz')
|
|
self.fields['requirements'].initial = _(u'Kondition für 20km und 600 Hm in ca. 7 Stunden Gehzeit.'
|
|
u' Trittsicherheit (mittelschwere Wege).')
|
|
else:
|
|
self.fields['equipment'].initial = _(u'Festes Schuhwerk, Regenschutz')
|
|
self.fields['requirements'].initial = _(u'Gehzeit X-Y Stunden, ca. X km, ca. X Hm')
|
|
|
|
|
|
class DescriptionForm(EventCreateForm):
|
|
_form_title = _(u'Titel / Beschreibung')
|
|
_next_form_name = 'RegistrationForm'
|
|
|
|
title = forms.CharField(max_length=config.TITLE_MAX_LENGTH,
|
|
label=_(u'Name/Titel der Veranstaltung'),
|
|
)
|
|
description = forms.CharField(label=_(u'Beschreibung'),
|
|
widget=forms.Textarea())
|
|
|
|
def _proceed_session_data(self, session_data):
|
|
super(DescriptionForm, self)._proceed_session_data(session_data)
|
|
|
|
mode = session_data.get('mode', None)
|
|
sport = session_data.get('sport', None)
|
|
level = session_data.get('level', None)
|
|
terrain = session_data.get('terrain', None)
|
|
last_day = session_data.get('last_day', None)
|
|
|
|
title_prefix = u''
|
|
if mode == 'training':
|
|
if level == 'beginner':
|
|
title_prefix += u'%s ' % ugettext(u'Grundkurs')
|
|
elif sport == 'B':
|
|
title_prefix += u'%s %s:' % (ugettext(u'Aufbaukurs'), ugettext(u'Alpin'))
|
|
else:
|
|
title_prefix += u'%s:' % ugettext(u'Aufbaukurs')
|
|
if sport == 'K':
|
|
if terrain == 'gym':
|
|
title_prefix += ugettext(u'Indoorklettern')
|
|
elif terrain == 'crag':
|
|
title_prefix += ugettext(u'Fels')
|
|
elif terrain == 'alpine':
|
|
title_prefix += ugettext(u'Mehrseillängen')
|
|
elif sport == 'W' and not last_day:
|
|
title_prefix += u'%s ' % ugettext(u'Tageswanderung')
|
|
|
|
if DEVELOPMENT_INIT_FORMS:
|
|
if not title_prefix:
|
|
title_prefix = u'Development Default Title'
|
|
|
|
self.fields['title'].initial = title_prefix
|
|
|
|
|
|
class RegistrationForm(EventCreateForm):
|
|
_form_title = _(u'Teilnehmer / Anmeldung')
|
|
_next_form_name = 'TrainerForm'
|
|
|
|
min_participants = forms.IntegerField(initial=0,
|
|
label=_(u'Min. Teilnehmer'))
|
|
max_participants = forms.IntegerField(initial=0,
|
|
label=_(u'Max. Teilnehmer'))
|
|
|
|
deadline = forms.ChoiceField(choices=choices.DEADLINE_CHOICES,
|
|
initial='OTHER',
|
|
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))
|
|
|
|
def _proceed_session_data(self, session_data):
|
|
super(RegistrationForm, self)._proceed_session_data(session_data)
|
|
|
|
first_day = session_data.get('first_day', None)
|
|
if first_day:
|
|
new_choices = []
|
|
for key, desc in self.fields['deadline'].choices:
|
|
if key == 'month':
|
|
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)
|
|
desc += u' ({})'.format(format_date(date, 'EEEE, d. MMMM yyyy', locale=get_language()[0:2]))
|
|
self.fields['deadline_month'].initial = date.isoformat()
|
|
elif key == 'quarter':
|
|
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)
|
|
desc += u' ({})'.format(format_date(date, 'EEEE, d. MMMM yyyy', locale=get_language()[0:2]))
|
|
self.fields['deadline_quarter'].initial = date.isoformat()
|
|
new_choices.append((key, desc))
|
|
self.fields['deadline'].choices = new_choices
|
|
|
|
|
|
class TrainerForm(EventCreateForm):
|
|
_form_title = _(u'Tourenleitung')
|
|
_next_form_name = 'ChargesForm'
|
|
|
|
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(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'Jens')
|
|
self.fields['trainer_familyname'].widget.attrs['placeholder'] = _(u'Kleineheismann')
|
|
self.fields['trainer_email'].widget.attrs['placeholder'] = _(u'heinzel@alpenverein-karlsruhe.de')
|
|
self.fields['trainer_phone'].widget.attrs['placeholder'] = _(u'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 DEVELOPMENT_INIT_FORMS:
|
|
self.fields['trainer_firstname'].initial = self.fields['trainer_firstname'].widget.attrs['placeholder']
|
|
self.fields['trainer_familyname'].initial = self.fields['trainer_familyname'].widget.attrs['placeholder']
|
|
self.fields['trainer_email'].initial = self.fields['trainer_email'].widget.attrs['placeholder']
|
|
|
|
|
|
class ChargesForm(EventCreateForm):
|
|
_form_title = _(u'Kosten')
|
|
_next_form_name = 'SummaryForm'
|
|
|
|
charge_key = forms.CharField(disabled=True,
|
|
label=_(u'Kostenschlüssel'),
|
|
)
|
|
trainer_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Pauschale Trainer*in'),
|
|
)
|
|
pre_meeting_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Pauschale Vortreffen'),
|
|
)
|
|
trainer_day_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Tagespauschale Trainer*in'),
|
|
)
|
|
participant_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Pauschale Teilnehmer*in'),
|
|
)
|
|
participant_day_fee = forms.FloatField(disabled=True,
|
|
label=_(u'Tagepauschale Teilnehmer*in'),
|
|
)
|
|
|
|
trainer_reward = forms.FloatField(disabled=True,
|
|
label=_(u'Aufwandsentschädigung Trainer*in'),
|
|
)
|
|
|
|
charge = forms.FloatField(label=_(u'Teilnahmegebühr'))
|
|
|
|
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'),
|
|
)
|
|
|
|
def _proceed_session_data(self, session_data):
|
|
super(ChargesForm, self)._proceed_session_data(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)
|
|
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)
|
|
|
|
if ski_lift:
|
|
charge_key = 'K'
|
|
elif sport == 'W' and not last_day:
|
|
charge_key = '0'
|
|
elif sport == 'W' and terrain != 'alpine':
|
|
charge_key = 'A'
|
|
elif sport == 'W':
|
|
charge_key = 'B'
|
|
elif terrain != 'alpine' and not last_day:
|
|
charge_key = 'C'
|
|
elif terrain != 'alpine':
|
|
charge_key = 'D'
|
|
elif mode == 'training' and country in ('DE', 'AU'):
|
|
charge_key = 'G'
|
|
elif mode == 'training':
|
|
charge_key = 'H'
|
|
elif sport == 'K' and country in ('DE', 'AU'):
|
|
charge_key = 'E'
|
|
elif sport == 'K':
|
|
charge_key = 'F'
|
|
elif country in ('DE', 'AU'):
|
|
charge_key = 'I'
|
|
else:
|
|
charge_key = 'J'
|
|
|
|
additional_costs_text = u''
|
|
if transport != 'NONE':
|
|
additional_costs_text += ugettext(u'Fahrtkosten')
|
|
|
|
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 += ugettext(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
|
|
|
|
fees = config.FEE_MATRIX[charge_key]
|
|
|
|
trainer_reward = (
|
|
fees['trainer_fee']
|
|
+ ndays * fees['trainer_day_fee']
|
|
+ n_pre_meetings * fees['pre_meeting_fee']
|
|
)
|
|
charge = (
|
|
fees['participant_fee']
|
|
+ ndays * fees['participant_day_fee']
|
|
)
|
|
if arrival_previous_day:
|
|
trainer_reward += fees['trainer_day_fee'] / 2.0
|
|
charge += fees['participant_day_fee'] / 2.0
|
|
|
|
self.fields['charge_key'].initial = fees['description'] or charge_key
|
|
self.fields['trainer_fee'].initial = fees['trainer_fee']
|
|
self.fields['pre_meeting_fee'].initial = fees['pre_meeting_fee']
|
|
self.fields['trainer_day_fee'].initial = fees['trainer_day_fee']
|
|
self.fields['participant_fee'].initial = fees['participant_day_fee']
|
|
self.fields['participant_day_fee'].initial = fees['participant_day_fee']
|
|
self.fields['trainer_reward'].initial = trainer_reward
|
|
|
|
self.fields['charge'].initial = charge
|
|
self.fields['additional_costs'].widget.attrs['placeholder'] = ugettext(u'Kann freigelassen werden')
|
|
self.fields['additional_costs'].initial = additional_costs_text
|
|
|
|
|
|
class SummaryForm(EventCreateForm):
|
|
_form_title = _(u'Zusammenfassung') |