def index(request, item_pk):
item = get_object_or_404(Item, pk=item_pk)
items = item.containing()
journal_entries = Journal.objects.filter(item=item)
if request.POST:
journal_form = JournalForm(request.POST)
if journal_form.is_valid():
journal_entry = journal_form.save(commit=False)
journal_entry.user = request.user.actor
journal_entry.item = item
journal_entry.save()
message_object_created(request, journal_entry)
return redirect(item)
else:
journal_form = JournalForm()
c = {
'item': item,
'items': items,
'journal_entries': journal_entries,
'journal_form': journal_form
}
return render(request, 'inventory/index.html', get_context_inventory(request, 'inventory-index', c))
def item_add(request, container_pk):
container = get_object_or_404(Item, pk=container_pk, is_container=True)
if request.POST:
form = ItemForm(request.POST)
if form.is_valid():
item = form.save(commit=False)
item.container = container
request.session['inventory_item_add_last_category'] = item.category
for x in range(0, form.cleaned_data['multiply']):
item.pk = None
item.save()
item.add_journal(request, _('Gegenstand wurde erfasst.'))
message_object_created(request, item)
if form.cleaned_data['multiply'] > 1:
target = container
elif item.type == Item.TYPE_CONTAINER:
target = item
else:
target = container
return redirect(target)
else:
form = ItemForm(
initial={
'category': request.session.get('inventory_item_add_last_category')
}
)
c = {
'container': container,
'form': form
}
return render(request, 'inventory/item-add.html', get_context_inventory(request, 'inventory-item-add', c))
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 item_copy(request, item_pk):
item = get_object_or_404(Item, pk=item_pk)
item.pk = None
item.save()
item.add_journal(request.user.actor, _('Gegenstand wurde als Kopie angelegt.'))
message_object_created(request, item)
return redirect(item.container)
def backstage_gallery_form(request, project):
project = get_project(request, project, 'manage_content')
slider = Slider.objects.get_or_create(name='gallery_%s' % project.pk)[0]
if request.POST and request.FILES:
form = SliderSinglePictureForm(request.POST, request.FILES)
if form.is_valid():
picture = form.save()
slider.add(picture)
message_object_created(request, picture)
else:
form = SliderSinglePictureForm()
if request.POST and not request.FILES:
if request.POST.get('delete'):
picture = SliderPicture.objects.get(pk=request.POST.get('delete'))
message_object_deleted(request, picture)
picture.delete()
if request.POST.get('up'):
SliderPicture.objects.get(pk=request.POST.get('up')).up()
if request.POST.get('down'):
SliderPicture.objects.get(pk=request.POST.get('down')).down()
return render(request, 'project/gallery-form.html',
get_context_backstage_project(request, project, 'bs-gallery',
{'project': project, 'gallery': slider, 'form': form}))
def backstage_role_add(request, project):
project = get_project(request, project, 'manage_roles')
if request.POST:
form_role = RoleForm(request.POST)
form_picture = RolePictureForm(request.POST, request.FILES)
if form_role.is_valid():
role = form_role.save(commit=False)
if form_picture.is_valid():
picture = form_picture.save(commit=False)
if role.actor:
picture.title = _(u'%s als %s' % (role.actor, role.name))
else:
picture.title = role.name
picture.save()
role.picture = picture
role.project = project
role.save()
message_object_created(request, role)
return redirect('bs-role-list', project=project.pk)
else:
form_role = RoleForm()
form_picture = RolePictureForm()
return render(request, 'project/role-form.html',
get_context_backstage_project(request, project, 'bs-role-form',
{'project': project, 'form_role': form_role,
'form_picture': form_picture}))
def backstage_application_approve(request, application_pk):
if request.POST.get('approve'):
a = get_object_or_404(MembershipApplication, pk=application_pk)
actor = Actor.objects.create_actor_by_application(a)
if actor:
message_object_created(request, actor)
else:
messages.error(request, _(
u'Der Mitgliedsantrag konnte nicht bestätigt werden. Bitte wenden Sie sich an den Administrator.'))
return redirect('bs-application-list')
def view_add(self, request, initial=None, amendment=None):
"""
This method handles the displaying and saving of a new instance of the defined class.
If successful, the user is redirected back to the list.
:rtype : HttpResponse
:type request: HttpRequest
:type initial: dict
:type amendment: dict
:param request: Django's HttpRequest-object
:param initial: Dictonary containing data with which the form should be prefilled
:param amendment: Dictonary with data, the created object should be filled.
"""
initial = initial or {}
amendment = amendment or {}
if not self.action_add:
raise SuspiciousOperation
if request.POST:
form = self.form(request.POST)
if form.is_valid():
obj = form.save(commit=False)
for amendment_key in amendment.keys():
obj.__setattr__(amendment_key, amendment[amendment_key])
obj.save()
message_object_created(request, obj)
if self.parent:
return redirect(self.url_list, self.parent.pk)
else:
return redirect(self.url_list)
else:
form = self.form(initial=initial)
c = {
'form': form
}
c.update(self.context)
return render(request, self.template_add, self.context_handler(request, self.url_add, c))
def backstage_fee_add(request, project):
project = get_project(request, project, 'is_manager')
if request.POST:
form = FeeForm(request.POST)
if form.is_valid():
fee = form.save(commit=False)
fee.project = project
fee.save()
message_object_created(request, fee)
return redirect('bs-fee-list', project=project.pk)
else:
form = FeeForm()
c = {
'project': project,
'view_title': Fee.objects.model._meta.verbose_name_plural,
'view_url_list': 'bs-fee-list',
'form': form,
}
return render(request, 'project/form.html',
get_context_backstage_project(request, project, 'bs-fee-add', c))
def backstage_event_add(request, project):
project = get_project(request, project, 'manage_dates')
if request.POST:
form = EventForm(request.POST)
if form.is_valid():
event = form.save(commit=False)
event.project = project
event.save()
message_object_created(request, event)
return redirect('bs-event-list', project=project.pk)
else:
form = EventForm()
c = {
'project': project,
'view_title': Event.objects.model._meta.verbose_name_plural,
'view_url_list': 'bs-event-list',
'form': form,
}
return render(request, 'project/form.html',
get_context_backstage_project(request, project, 'bs-event-add', c))
def webcontent_slider_form(request):
slider = Slider.objects.get_or_create(name='_homepage')[0]
if request.POST and request.FILES:
form = SliderSinglePictureForm(request.POST, request.FILES)
if form.is_valid():
picture = form.save()
message_object_created(request, picture)
slider.add(picture)
else:
form = SliderSinglePictureForm()
if request.POST and not request.FILES:
if request.POST.get('delete'):
picture = SliderPicture.objects.get(pk=request.POST.get('delete'))
message_object_deleted(request, picture)
picture.delete()
if request.POST.get('up'):
SliderPicture.objects.get(pk=request.POST.get('up')).up()
if request.POST.get('down'):
SliderPicture.objects.get(pk=request.POST.get('down')).down()
return render(request, 'webcontent/slider-form.html',
get_context_webmaster(request, 'webcontent-slider-form', {'slider': slider, 'form': form}))
def index(request, file_pk=None, directory_pk=None):
# Neither file nor directory, show root directories
if not file_pk and not directory_pk:
directories = Directory.objects.get_root_directories(request.user.actor)
directory = None
current_file = None
url_to_post = reverse('fs-index')
else:
# directory is given
if directory_pk:
current_file = None
directory = get_object_or_404(Directory, pk=directory_pk)
url_to_post = directory.get_absolute_url
# or file?
else:
current_file = get_object_or_404(File, pk=file_pk)
url_to_post = current_file.get_absolute_url
directory = current_file.directory
directories = directory.get_directories(request.user.actor)
if directory:
new_directory_form = NewDirectoryForm(user=request.user, initial={
'parent': directory,
'owner': directory.owner.pk,
'restrict_read_to': directory.restrict_read_to.all(),
'restrict_write_to': directory.restrict_write_to.all(),
})
edit_directory_form = EditDirectoryForm(instance=directory, user=request.user)
new_file_form = NewFileForm(initial={
'directory': directory
})
files = directory.get_files()
is_owner = directory.is_owner(request.user.actor)
can_write = directory.can_write(request.user.actor)
else:
new_directory_form = NewDirectoryForm(user=request.user)
edit_directory_form = None
new_file_form = None
files = None
is_owner = request.user.is_superuser
can_write = request.user.is_superuser
if directory and not directory.can_read(request.user.actor):
messages.error(request, _(u'Dir fehlen die erforderlichen Leserechte für dieses Verzeichnis.'))
raise PermissionDenied
# maybe a post
if 'action' in request.POST:
# check for sufficient rights
if directory and not directory.can_write(request.user.actor):
messages.error(request, _(u'Du hast für das Verzeichnis nicht die erforderlichen Schreibrechte.'))
raise PermissionDenied
elif not directory and not request.user.is_superuser:
messages.error(request, _(u'Du musst Administrator sein, um hier Verzeichnisse anzulegen.'))
raise PermissionDenied
# what's the action?
# create file
if request.POST['action'] == 'create_file':
if directory and can_write:
new_file_form = NewFileForm(request.POST, request.FILES)
if new_file_form.is_valid():
new_file = new_file_form.save(commit=False)
new_file.uploader = request.user.actor
new_file.filename = request.FILES['file'].name
new_file.save()
message_object_created(request, new_file)
return redirect(new_file)
# delete file
if request.POST['action'] == 'delete_file':
if current_file and current_file.can_write(request.user.actor):
message_object_deleted(request, current_file)
target = current_file.directory
current_file.delete()
return redirect(target)
# create directory
if request.POST['action'] == 'create_directory':
if can_write:
new_directory_form = NewDirectoryForm(request.POST, user=request.user)
if new_directory_form.is_valid():
new_directory = new_directory_form.save()
message_object_created(request, new_directory)
return redirect(new_directory)
# modify directory settings
if request.POST['action'] == 'edit_directory' and directory:
if is_owner:
edit_directory_form = EditDirectoryForm(request.POST, instance=directory, user=request.user)
if edit_directory_form.is_valid():
edit_directory = edit_directory_form.save()
message_object_updated(request, edit_directory)
return redirect(edit_directory)
# delete directory
if request.POST['action'] == 'delete_directory':
if is_owner:
if directory.parent_id:
target = directory.parent
else:
target = 'fs-index'
message_object_deleted(request, directory)
directory.delete()
return redirect(target)
# download a file
if request.POST['action'] == 'download':
response = HttpResponse(current_file.file.read(),
content_type=current_file.content_type or 'application/force-download')
response['Content-Length'] = current_file.size
response['Content-Disposition'] = 'attachment; filename="%s"' % current_file.filename
return response
c = {
'directory': directory,
'directories': directories,
'files': files,
'file': current_file,
'new_directory_form': new_directory_form,
'new_file_form': new_file_form,
'edit_directory_form': edit_directory_form,
'current_item': current_file or directory,
'url_to_post': url_to_post,
'can_write': can_write,
'is_owner': is_owner
}
return render(request, 'filestorage/index.html', get_context_filestorage(request, 'fs-index', c))
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}))
