def actor_data_form(request):
actor = request.user.actor
success_messages = []
if request.POST:
form = ActorDataForm(request.POST, instance=actor)
if form.is_valid():
form.save()
success_messages.append(_(u'Deine Stammdaten wurden aktualisiert.'))
form_picture = PictureMembershipForm(request.POST, request.FILES, instance=actor.picture_membership)
if form_picture.is_valid():
form_picture.title = actor.__unicode__()
actor.picture_membership = form_picture.save()
actor.save()
success_messages.append(_(u'Dein internes Profilbild wurde aktualisiert.'))
else:
form = ActorDataForm(instance=actor)
form_picture = PictureMembershipForm(instance=actor.picture_membership)
if success_messages:
messages.success(request, ' '.join(success_messages))
c = {
'form': form,
'form_picture': form_picture
}
return render(request, 'backstage/actor-data-form.html', get_context_backstage(request,
'actor-data-form',
c))
def actor_init_form(request):
try:
actor = request.user.actor
return redirect('backstage')
except Actor.DoesNotExist:
actor = Actor(user=request.user, status=Configuration.objects.current().default_status)
if request.POST:
form_public = ActorPublicForm(request.POST, instance=actor)
form_data = ActorDataForm(request.POST, instance=actor)
form_group = UserGroupForm(request.POST)
if form_public.is_valid() and form_data.is_valid() and form_group.is_valid():
form_public.save()
form_data.save()
request.user.groups.add(form_group.cleaned_data['group'])
messages.success(request, _(
u'Vielen Dank! Damit hast du nun dein Profil angelegt. Bitte melde dich nun noch mal an.'))
return redirect('logout')
else:
form_public = ActorPublicForm(instance=actor)
form_data = ActorDataForm(instance=actor)
form_group = UserGroupForm()
forms = ((_(u'Öffentliches Profil'), form_public),
(_('Stammdaten'), form_data),
(_(u'Gruppenzugehörigkeit'), form_group))
return render(request, 'backstage/actor-init-form.html',
get_context_backstage(request, 'actor-init-form', {'forms': forms}))
def backstage_project_add(request):
if request.POST:
form = ProjectAddForm(request.POST)
if form.is_valid():
actor = form.cleaned_data['manager']
project = Project.objects.create(title=form.cleaned_data['title'])
Role.objects.create(name=Role._meta.get_field('perm_is_manager').verbose_name, project=project,
actor=actor, appearance=1)
request.get_full_path()
mail = EMailTemplate.objects.prepare('project-added', {
'first_name': actor.user.first_name,
'last_name': actor.user.last_name,
'admin': request.user,
'project': project,
'dashboard_url': request.build_absolute_uri(reverse('bs-dashboard', kwargs={'project': project.pk}))
})
mail.to = [actor.user.email, ]
mail.send()
message_object_created(request, project)
return redirect('bs-dashboard', project=project.pk)
else:
form = ProjectAddForm()
return render(request, 'administrator/projects-form.html',
get_context_backstage(request, 'bs-project-add', {'form': form}))
def get_context_filestorage(request, active_page, upd_dict=None):
d = {
'tpl__active_organization': True
}
if not upd_dict:
upd_dict = d
else:
upd_dict.update(d)
return get_context_backstage(request, active_page, upd_dict)
def backstage_project_list(request):
object_list = Project.objects.by_premiere()
c = {
'object_list': object_list,
'url_add': 'bs-project-add',
'action_add': True,
'url_list': 'bs-project-list',
'verbose_name_plural': Project.objects.model._meta.verbose_name_plural,
}
return render(request, 'backstage/project-list.html',
get_context_backstage(request, 'bs-project-list', c))
def backstage(request):
actor = request.user.actor
if actor.can_affirm_memberships():
applications = MembershipApplication.objects.filter(mail_confirmed__isnull=False).exclude(
members_confirmed=request.user.actor)
else:
applications = None
admins = Actor.objects.filter(user__is_superuser=True)
period = Period.objects.get_current()
wiki_pages = Page.objects.get_most_recent(request.user)[:4]
if request.user.has_perm('organization.treasurer'):
last_added_entries = Entry.objects.order_by('-entry_date')[:4]
else:
last_added_entries = None
current_hour = datetime.now().hour
if current_hour in range(0, 5):
greeting = _(u'Hallo Nachtschwärmer')
elif current_hour in range(6, 9):
greeting = _('Guten Morgen')
elif current_hour in range(12, 14):
greeting = _('Mahlzeit')
elif current_hour in range(19, 24):
greeting = _('Guten Abend')
else:
greeting = _('Willkommen')
greeting = u'{greeting}, {fullname}!'.format(greeting=greeting, fullname=request.user.actor)
upcoming_birthdays = Actor.objects.upcoming_birthdays(Configuration.objects.current().show_number_of_birthdays)
second_row = not actor.get_membership_fee_paid()['paid'] or applications or not actor.password_recovery_email
c = {
'admins': admins,
'applications': applications,
'period': period,
'wiki_pages': wiki_pages,
'greeting': greeting,
'upcoming_birthdays': upcoming_birthdays,
'last_added_entries': last_added_entries,
'second_row': second_row
}
return render(request, 'backstage/dashboard.html', get_context_backstage(request, 'backstage', c))
def password_policy_form(request):
if request.POST:
form = ActorPasswordForm(request.POST)
if form.is_valid():
password_old = form.cleaned_data['password_old']
if request.user.actor.check_password(password_old) is not True:
form.errors['password_old'] = _(u'Das eingegebene Passwort ist nicht das aktuelle.')
else:
request.user.actor.set_password(form.cleaned_data['password_1'])
messages.success(request,
_(u'Dein Passwort wurde erfolgreich geändert. Bitte melde dich nun neu an.'))
return redirect('logout')
else:
form = ActorPasswordForm()
return render(request, 'backstage/password-policy-form.html',
get_context_backstage(request, 'password-policy-form', {'form': form}))
def board_memberlist(request):
filter_isactive_active, filter_isactive_inactive = '1', '2'
filter_isactive_current = None
a = Actor.objects.all()
if 'filter_isactive' in request.GET:
filter_isactive = request.GET.get('filter_isactive')
if filter_isactive == filter_isactive_active:
a = a.filter(user__is_active=True)
filter_isactive_current = filter_isactive_active
elif filter_isactive == filter_isactive_inactive:
a = a.filter(user__is_active=False)
filter_isactive_current = filter_isactive_inactive
select_status_form = SelectStatusForm()
form_recovery_by_admin = RecoveryByAdminForm()
if request.POST:
post_action = request.POST.get('action', None)
if 'update_status' == post_action:
select_status_form = SelectStatusForm(request.POST)
if select_status_form.is_valid():
status = select_status_form.cleaned_data['status']
gl = request.POST.getlist('user_selection')
Actor.objects.filter(pk__in=gl).update(status=status)
messages.success(request, _(u'Es wurden {number} Mitglied(er) auf den '
u'Status {status} gesetzt.'.format(number=len(gl), status=status)))
if 'recovery_by_admin' == post_action:
form_recovery_by_admin = RecoveryByAdminForm(request.POST)
if form_recovery_by_admin.is_valid():
actor = get_object_or_404(Actor, pk=request.POST.get('actor_pk', None))
actor.invoke_recovery_email_confirmation(request, form_recovery_by_admin.cleaned_data['recovery_email'])
messages.success(request, _(u'Eine E-Mail wurde an <em>{0}</em> gesendet.'.format(actor)))
return redirect('bs-board-memberlist')
c = {
'objects': a,
'select_status_form': select_status_form,
'form_recovery_by_admin': form_recovery_by_admin,
'filter_isactive': {
'active': filter_isactive_active,
'inactive': filter_isactive_inactive,
'current': filter_isactive_current,
},
}
return render(request, 'backstage/board-member-list.html',
get_context_backstage(request, 'bs-board-memberlist', c))
def board_member_form(request, actor_pk):
a = get_object_or_404(Actor, pk=actor_pk)
if request.POST:
form_actor = BoardActorForm(request.POST, instance=a)
form_user = BoardUserForm(request.POST, instance=a.user)
if form_actor.is_valid() and form_actor.is_valid():
form_actor.save()
form_user.save()
message_object_updated(request, a)
else:
form_actor = BoardActorForm(instance=a)
form_user = BoardUserForm(instance=a.user)
forms = (form_actor, form_user)
return render(request, 'backstage/board-member-form.html', get_context_backstage(request, 'bs-board-member-form',
{'actor': a, 'forms': forms}))
def actor_password_form(request):
form = ActorPasswordForm()
form_recovery = ActorRecoverPasswordForm(initial={'recovery_email': request.user.actor.password_recovery_email})
if request.POST:
if 'set_password' == request.POST.get('action'):
form = ActorPasswordForm(request.POST)
if form.is_valid():
password_old = form.cleaned_data['password_old']
if request.user.actor.check_password(password_old) is not True:
form.errors['password_old'] = _(u'Das eingegebene Passwort ist nicht das aktuelle.')
else:
request.user.actor.set_password(form.cleaned_data['password_1'])
messages.success(request,
_(u'Dein Passwort wurde erfolgreich geändert. Bitte melde dich nun neu an.'))
return redirect('logout')
elif 'set_recovery' == request.POST.get('action'):
form_recovery = ActorRecoverPasswordForm(request.POST)
if form_recovery.is_valid():
password_old = form_recovery.cleaned_data['password_old']
if request.user.actor.check_password(password_old) is not True:
form_recovery.errors['password_old'] = _(u'Das eingegebene Passwort ist nicht das aktuelle.')
if request.user.email == form_recovery.cleaned_data['recovery_email']:
form_recovery.errors['recovery_email'] = _(
u'Das darf nicht deine normale E-Mail-Adresse sein. Bitte verwende eine andere.')
if not form_recovery.errors:
request.user.actor.invoke_recovery_email_confirmation(request,
form_recovery.cleaned_data['recovery_email'])
messages.success(request, _(
u'Dir wurde eine E-Mail an {email} gesendet. Bitte klicke auf den Link in dieser E-Mail um '
u'deine E-Mail-Adresse zu bestätigen. Erst dann kannst du sie zur Passwort-Wiederherstellung '
u'verwendet.'.format(email=request.user.actor.password_recovery_email_new)))
c = {
'form': form,
'form_recovery': form_recovery
}
return render(request, 'backstage/actor-password-form.html',
get_context_backstage(request, 'actor-password-form', c))
def actor_public_form(request):
try:
actor = request.user.actor
except:
actor = Actor(user=request.user)
success_messages = []
if request.POST and actor:
form = ActorPublicForm(request.POST, instance=actor)
if form.is_valid():
form.save()
success_messages.append(u'Dein öffentliches Profil wurde aktualisiert.')
form_picture = PicturePublicForm(request.POST, request.FILES, instance=actor.picture_public)
if form_picture.is_valid():
form_picture.title = actor.__unicode__()
actor.picture_public = form_picture.save()
actor.save()
success_messages.append(u'Dein öffentliches Profilbild wurde aktualisiert.')
else:
form = ActorPublicForm(instance=actor)
form_picture = PicturePublicForm(instance=actor.picture_public)
if success_messages:
messages.success(request, ' '.join(success_messages))
c = {
'form': form,
'form_picture': form_picture,
'actor_slug': actor.slug,
}
return render(request, 'backstage/actor-public-form.html', get_context_backstage(request, 'actor-public-form',
c))
def backstage_application_list(request):
o = MembershipApplication.objects.all()
return render(request, 'backstage/board-application-list.html',
get_context_backstage(request, 'bs-application-list', {'objects': o}))
def backstage_group_list(request):
groups = Group.objects.all()
unassigned = Actor.objects.filter(user__groups__isnull=True)
return render(request, 'backstage/group-list.html',
get_context_backstage(request, 'backstage-group-list',
{'groups': groups, 'unassigned': unassigned}))
def actor_finance(request):
actor = request.user.actor
# First: collect membership fee status
periods = Period.objects.all()[:5]
status = {}
if len(periods) > 0:
for period in periods:
status.update({period.pk: {'paid': False, 'amount': 0}})
status[period.pk] = actor.get_membership_fee_paid(period)
actor.fee_status = status
# Second: prepare and execute refund data form
if request.POST and 'refund_obligee' in request.POST and 'refund_iban' in request.POST and 'refund_swift_bic' in request.POST:
actor_refund_data_form = ActorRefundDataForm(request.POST, instance=actor)
if actor_refund_data_form.is_valid():
messages.success(request, _(u'Deine Konto-Informationen für Erstattungen wurden aktualisiert.'))
actor_refund_data_form.save()
else:
actor_refund_data_form = ActorRefundDataForm(instance=actor)
# Third: prepare sepa mandate form
if 'new_sepa' == request.POST.get('form', False):
actor_sepa_mandate_form = SEPAMandateCreateForm(request.POST)
actor_sepa_mandate_form.instance.actor = request.user.actor
if actor_sepa_mandate_form.is_valid():
sepa_mandate = actor_sepa_mandate_form.save()
message_object_created(request, sepa_mandate)
else:
actor_sepa_mandate_form = SEPAMandateCreateForm()
if request.POST.get('delete', False):
mandate = get_object_or_404(SEPAMandate, pk=request.POST.get('delete'), actor=actor)
if mandate.state is SEPAMandate.STATE_PENDING or not mandate.keep_until() or mandate.keep_until() < datetime.now().date():
message_object_deleted(request, mandate)
mandate.delete()
if request.POST.get('revoke', False):
mandate = get_object_or_404(SEPAMandate, pk=request.POST.get('delete'), actor=actor)
message_object_updated(request, mandate)
mandate.state = mandate.STATE_REVOKED
mandate.save()
active_mandate = SEPAMandate.objects.get_active(actor=actor)
pending_mandate = SEPAMandate.objects.get_pending(actor=actor)
other_mandates = SEPAMandate.objects.get_other(actor=actor)
# Fourth: creditor accounts
creditor_accounts = Account.objects.filter(is_creditor=True)
try:
current_period = periods[0]
except ValueError:
current_period = None
return render(request, 'backstage/actor-finance.html', get_context_backstage(request, 'actor-finance', {
'actor': actor, 'periods': periods, 'actor_refund_data_form': actor_refund_data_form, 'actor_sepa_mandate_form':
actor_sepa_mandate_form, 'active_mandate': active_mandate, 'pending_mandate': pending_mandate,
'other_mandates': other_mandates, 'creditor_accounts': creditor_accounts, 'current_period': current_period}))
