team-3/src/c3nav/editor/views/edit.py

719 lines
30 KiB
Python
Raw Normal View History

import mimetypes
import os
2017-07-14 15:32:14 +02:00
import typing
from contextlib import suppress
2017-05-14 20:21:33 +02:00
from django.conf import settings
from django.contrib import messages
from django.core.cache import cache
from django.core.exceptions import FieldDoesNotExist, ObjectDoesNotExist, PermissionDenied
2017-12-22 23:51:57 +01:00
from django.db import IntegrityError, models
2017-11-25 20:32:05 +01:00
from django.db.models import Q
from django.http import Http404, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
2017-05-14 20:21:33 +02:00
from django.urls import reverse
2017-05-16 17:45:56 +02:00
from django.utils.translation import ugettext_lazy as _
2017-10-27 17:08:36 +02:00
from django.views.decorators.http import etag
2016-09-23 15:23:02 +02:00
from c3nav.editor.forms import GraphEdgeSettingsForm, GraphEditorActionForm
2018-11-21 21:49:49 +01:00
from c3nav.editor.views.base import (APIHybridError, APIHybridFormTemplateResponse, APIHybridLoginRequiredResponse,
2018-11-21 22:07:06 +01:00
APIHybridMessageRedirectResponse, APIHybridTemplateContextResponse, etag_func,
sidebar_view)
2017-11-25 20:32:05 +01:00
from c3nav.mapdata.models.access import AccessPermission
from c3nav.mapdata.utils.user import can_access_editor
2017-05-14 20:21:33 +02:00
2017-07-14 15:32:14 +02:00
def child_model(request, model: typing.Union[str, models.Model], kwargs=None, parent=None):
model = request.changeset.wrap_model(model)
related_name = model._meta.default_related_name
2017-07-14 00:08:34 +02:00
if parent is not None:
qs = getattr(parent, related_name)
if hasattr(model, 'q_for_request'):
qs = qs.filter(model.q_for_request(request))
count = qs.count()
else:
count = None
return {
'title': model._meta.verbose_name_plural,
'url': reverse('editor.'+related_name+'.list', kwargs=kwargs),
2017-07-14 00:08:34 +02:00
'count': count,
}
2018-11-21 22:07:06 +01:00
@sidebar_view(api_hybrid=True)
2017-10-27 17:08:36 +02:00
@etag(etag_func)
def main_index(request):
Level = request.changeset.wrap_model('Level')
2018-11-21 22:07:06 +01:00
return APIHybridTemplateContextResponse('editor/index.html', {
'levels': Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
2018-11-20 22:54:29 +01:00
'can_create_level': (request.user_permissions.can_access_base_mapdata and
request.changeset.can_edit(request)),
'child_models': [
child_model(request, 'LocationGroupCategory'),
child_model(request, 'LocationGroup'),
2017-07-27 18:58:51 +02:00
child_model(request, 'WayType'),
child_model(request, 'AccessRestriction'),
2017-12-20 20:54:58 +01:00
child_model(request, 'AccessRestrictionGroup'),
child_model(request, 'Source'),
],
2018-11-21 22:07:06 +01:00
}, fields=('can_create_level', 'child_models'))
2017-05-14 20:21:33 +02:00
2018-11-21 22:12:34 +01:00
@sidebar_view(api_hybrid=True)
2017-10-27 17:08:36 +02:00
@etag(etag_func)
2017-06-11 14:43:14 +02:00
def level_detail(request, pk):
Level = request.changeset.wrap_model('Level')
qs = Level.objects.filter(Level.q_for_request(request))
level = get_object_or_404(qs.select_related('on_top_of').prefetch_related('levels_on_top'), pk=pk)
2017-05-16 12:34:45 +02:00
2018-11-20 22:54:29 +01:00
if request.user_permissions.can_access_base_mapdata:
submodels = ('Building', 'Space', 'Door')
else:
submodels = ('Space', )
2018-11-21 22:12:34 +01:00
return APIHybridTemplateContextResponse('editor/level.html', {
'levels': Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
2017-06-11 14:43:14 +02:00
'level': level,
'level_url': 'editor.levels.detail',
'level_as_pk': True,
2018-11-20 22:54:29 +01:00
'can_edit_graph': request.user_permissions.can_access_base_mapdata,
'can_create_level': (request.user_permissions.can_access_base_mapdata and
request.changeset.can_edit(request)),
'child_models': [child_model(request, model_name, kwargs={'level': pk}, parent=level)
2018-11-20 22:54:29 +01:00
for model_name in submodels],
'levels_on_top': level.levels_on_top.filter(Level.q_for_request(request)).all(),
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?level='+str(level.primary_level_pk)
if request.user_permissions.can_access_base_mapdata else None),
2018-11-21 22:12:34 +01:00
}, fields=('level', 'can_edit_graph', 'can_create_level', 'child_models', 'levels_on_top'))
2018-11-21 22:15:21 +01:00
@sidebar_view(api_hybrid=True)
2017-10-27 17:08:36 +02:00
@etag(etag_func)
2017-06-11 14:43:14 +02:00
def space_detail(request, level, pk):
Level = request.changeset.wrap_model('Level')
Space = request.changeset.wrap_model('Space')
qs = Space.objects.filter(Space.q_for_request(request))
space = get_object_or_404(qs.select_related('level'), level__pk=level, pk=pk)
can_edit = request.user_permissions.can_access_base_mapdata or space.base_mapdata_accessible
if can_edit:
2018-11-20 22:54:29 +01:00
submodels = ('POI', 'Area', 'Obstacle', 'LineObstacle', 'Stair', 'Ramp', 'Column',
'Hole', 'AltitudeMarker', 'LeaveDescription', 'CrossDescription',
'WifiMeasurement')
else:
submodels = ('POI', 'Area', 'AltitudeMarker', 'LeaveDescription', 'CrossDescription')
2018-11-21 22:15:21 +01:00
return APIHybridTemplateContextResponse('editor/space.html', {
'levels': Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
2017-06-11 14:43:14 +02:00
'level': space.level,
'level_url': 'editor.spaces.list',
'space': space,
'can_edit_graph': can_edit,
'child_models': [child_model(request, model_name, kwargs={'space': pk}, parent=space)
2018-11-20 22:54:29 +01:00
for model_name in submodels],
2018-11-21 17:59:03 +01:00
'geometry_url': '/api/editor/geometries/?space='+pk if can_edit else None,
2018-11-21 22:15:21 +01:00
}, fields=('level', 'space', 'can_edit_graph', 'child_models'))
2017-05-14 20:21:33 +02:00
2017-12-19 17:00:06 +01:00
def get_changeset_exceeded(request):
return request.user_permissions.max_changeset_changes <= request.changeset.changed_objects_count
2018-11-21 21:49:49 +01:00
@sidebar_view(api_hybrid=True, allow_post=True, allow_delete=True)
2017-10-27 17:08:36 +02:00
@etag(etag_func)
2017-06-11 14:43:14 +02:00
def edit(request, pk=None, model=None, level=None, space=None, on_top_of=None, explicit_edit=False):
2017-12-19 17:00:06 +01:00
changeset_exceeded = get_changeset_exceeded(request)
model_changes = {}
if changeset_exceeded:
model_changes = request.changeset.get_changed_objects_by_model(model)
model = request.changeset.wrap_model(model)
related_name = model._meta.default_related_name
2016-10-13 15:55:15 +02:00
Level = request.changeset.wrap_model('Level')
Space = request.changeset.wrap_model('Space')
can_edit = request.changeset.can_edit(request)
2018-11-20 22:54:29 +01:00
if pk is None and not request.user_permissions.can_access_base_mapdata:
raise PermissionDenied
obj = None
if pk is not None:
2016-11-27 23:51:44 +01:00
# Edit existing map item
kwargs = {'pk': pk}
2017-06-11 15:37:25 +02:00
qs = model.objects.all()
if hasattr(model, 'q_for_request'):
qs = qs.filter(model.q_for_request(request))
2017-06-11 14:43:14 +02:00
if level is not None:
kwargs.update({'level__pk': level})
2017-06-11 15:37:25 +02:00
qs = qs.select_related('level')
if not request.user_permissions.can_access_base_mapdata:
can_edit = False
elif space is not None:
kwargs.update({'space__pk': space})
2017-06-11 15:37:25 +02:00
qs = qs.select_related('space')
2018-11-20 22:54:29 +01:00
else:
if not request.user_permissions.can_access_base_mapdata:
can_edit = False
2017-06-11 15:37:25 +02:00
obj = get_object_or_404(qs, **kwargs)
2017-06-11 14:43:14 +02:00
elif level is not None:
level = get_object_or_404(Level.objects.filter(Level.q_for_request(request)), pk=level)
2017-05-26 17:52:29 +02:00
elif space is not None:
space = get_object_or_404(Space.objects.filter(Space.q_for_request(request)), pk=space)
2017-06-11 01:19:37 +02:00
elif on_top_of is not None:
on_top_of = get_object_or_404(Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
pk=on_top_of)
2016-09-26 13:32:05 +02:00
new = obj is None
2018-11-20 22:54:29 +01:00
# noinspection PyProtectedMember
ctx = {
'path': request.path,
'pk': pk,
2017-05-26 17:06:52 +02:00
'model_name': model.__name__.lower(),
'model_title': model._meta.verbose_name,
'can_edit': can_edit,
'new': new,
'title': obj.title if obj else None,
}
with suppress(FieldDoesNotExist):
2017-05-26 21:37:39 +02:00
ctx.update({
'geomtype': model._meta.get_field('geometry').geomtype,
})
space_id = None
force_geometry_editable = False
2017-06-11 14:43:14 +02:00
if model == Level:
ctx.update({
2017-06-11 14:43:14 +02:00
'level': obj,
'back_url': reverse('editor.index') if new else reverse('editor.levels.detail', kwargs={'pk': pk}),
2017-06-18 01:08:04 +02:00
'nozoom': True,
})
if not new:
ctx.update({
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?level='+str(obj.primary_level_pk)
if request.user_permissions.can_access_base_mapdata else None),
2017-06-11 01:19:37 +02:00
'on_top_of': obj.on_top_of,
})
elif on_top_of:
ctx.update({
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?level=' + str(on_top_of.pk)
if request.user_permissions.can_access_base_mapdata else None),
2017-06-11 01:19:37 +02:00
'on_top_of': on_top_of,
2017-06-11 14:43:14 +02:00
'back_url': reverse('editor.levels.detail', kwargs={'pk': on_top_of.pk}),
})
elif model == Space and not new:
2017-06-11 14:43:14 +02:00
level = obj.level
ctx.update({
2017-06-11 14:43:14 +02:00
'level': obj.level,
'back_url': reverse('editor.spaces.detail', kwargs={'level': obj.level.pk, 'pk': pk}),
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?space='+pk
if request.user_permissions.can_access_base_mapdata else None),
2017-06-18 01:08:04 +02:00
'nozoom': True,
})
2017-05-26 19:58:04 +02:00
elif model == Space and new:
ctx.update({
2017-06-11 14:43:14 +02:00
'level': level,
'back_url': reverse('editor.spaces.list', kwargs={'level': level.pk}),
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?level='+str(level.primary_level_pk)
if request.user_permissions.can_access_base_mapdata else None),
2017-06-18 01:08:04 +02:00
'nozoom': True,
2017-05-26 19:58:04 +02:00
})
2017-06-11 14:43:14 +02:00
elif hasattr(model, 'level'):
2017-06-13 03:31:10 +02:00
if not new:
2017-06-11 14:43:14 +02:00
level = obj.level
ctx.update({
2017-06-11 14:43:14 +02:00
'level': level,
'back_url': reverse('editor.'+related_name+'.list', kwargs={'level': level.pk}),
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?level='+str(level.primary_level_pk)
if request.user_permissions.can_access_base_mapdata else None),
})
2017-05-26 17:52:29 +02:00
elif hasattr(model, 'space'):
2017-06-13 03:31:10 +02:00
if not new:
2017-05-26 17:52:29 +02:00
space = obj.space
2017-12-19 02:32:04 +01:00
space_id = space.pk
force_geometry_editable = (request.user_permissions.can_access_base_mapdata or space.base_mapdata_accessible)
ctx.update({
2017-06-11 14:43:14 +02:00
'level': space.level,
'back_url': reverse('editor.'+related_name+'.list', kwargs={'space': space.pk}),
2018-11-21 17:59:03 +01:00
'geometry_url': '/api/editor/geometries/?space='+str(space.pk) if force_geometry_editable else None,
})
2017-05-16 17:45:56 +02:00
else:
kwargs = {}
2017-06-11 14:43:14 +02:00
if level is not None:
kwargs.update({'level': level})
elif space is not None:
kwargs.update({'space': space})
kwargs.update(get_visible_spaces_kwargs(model, request))
2017-05-16 17:45:56 +02:00
ctx.update({
'back_url': reverse('.'.join(request.resolver_match.url_name.split('.')[:-1]+['list']), kwargs=kwargs),
2017-05-16 17:45:56 +02:00
})
2017-12-19 17:00:06 +01:00
nosave = False
if changeset_exceeded:
if new:
2018-11-21 21:49:49 +01:00
return APIHybridMessageRedirectResponse(
level='error', message=_('You can not create new objects because your changeset is full.'),
redirect_to=ctx['back_url']
)
2017-12-19 17:00:06 +01:00
elif obj.pk not in model_changes:
messages.warning(request, _('You can not edit this object because your changeset is full.'))
nosave = True
ctx.update({
2017-12-19 17:31:27 +01:00
'nosave': nosave
2017-12-19 17:00:06 +01:00
})
2017-08-03 19:26:40 +02:00
if new:
ctx.update({
'nozoom': True
})
2017-12-21 03:52:56 +01:00
if new and model.__name__ == 'WifiMeasurement' and not request.user.is_authenticated:
2018-11-21 21:49:49 +01:00
return APIHybridLoginRequiredResponse(next=request.path_info, login_url='editor.login', level='info',
message=_('You need to log in to create Wifi Measurements.'))
2018-11-21 21:49:49 +01:00
error = None
2016-09-26 13:32:05 +02:00
if request.method == 'POST':
2017-12-19 17:00:06 +01:00
if nosave:
2018-11-21 21:49:49 +01:00
return APIHybridMessageRedirectResponse(
level='error', message=_('You can not edit this object because your changeset is full.'),
redirect_to=request.path
)
2017-12-19 17:00:06 +01:00
if not can_edit:
2018-11-21 21:49:49 +01:00
return APIHybridMessageRedirectResponse(
level='error', message=_('You can not edit this object.'),
redirect_to=request.path
)
2017-06-13 03:31:10 +02:00
if not new and request.POST.get('delete') == '1':
2016-11-27 23:51:44 +01:00
# Delete this mapitem!
try:
if not request.changeset.get_changed_object(obj).can_delete():
raise PermissionError
except (ObjectDoesNotExist, PermissionError):
2018-11-21 21:49:49 +01:00
return APIHybridMessageRedirectResponse(
level='error',
message=_('You can not delete this object because other objects still depend on it.'),
redirect_to=request.path
)
2016-09-26 13:32:05 +02:00
if request.POST.get('delete_confirm') == '1':
2017-07-07 15:32:41 +02:00
with request.changeset.lock_to_edit(request) as changeset:
if changeset.can_edit(request):
obj.delete()
2017-07-07 15:32:41 +02:00
else:
2018-11-21 21:49:49 +01:00
return APIHybridMessageRedirectResponse(
level='error',
message=_('You can not edit changes on this changeset.'),
redirect_to=request.path
)
redirect_to = None
2017-06-11 14:43:14 +02:00
if model == Level:
2017-06-11 01:19:37 +02:00
if obj.on_top_of_id is not None:
2018-11-21 21:49:49 +01:00
redirect_to = reverse('editor.levels.detail', kwargs={'pk': obj.on_top_of_id})
else:
redirect_to = reverse('editor.index')
2017-05-26 19:58:04 +02:00
elif model == Space:
2018-11-21 21:49:49 +01:00
redirect_to = reverse('editor.spaces.list', kwargs={'level': obj.level.pk})
else:
redirect_to = ctx['back_url']
return APIHybridMessageRedirectResponse(
level='success',
message=_('Object was successfully deleted.'),
redirect_to=redirect_to
)
ctx['obj_title'] = obj.title
return render(request, 'editor/delete.html', ctx)
form = model.EditorForm(instance=model() if new else obj, data=request.POST,
request=request, space_id=space_id, force_geometry_editable=force_geometry_editable)
2016-09-26 13:32:05 +02:00
if form.is_valid():
# Update/create objects
obj = form.save(commit=False)
2016-10-13 15:55:15 +02:00
2017-06-11 14:43:14 +02:00
if level is not None:
obj.level = level
2017-05-26 19:58:04 +02:00
if space is not None:
obj.space = space
2017-06-11 01:19:37 +02:00
if on_top_of is not None:
obj.on_top_of = on_top_of
2017-07-07 15:32:41 +02:00
with request.changeset.lock_to_edit(request) as changeset:
if changeset.can_edit(request):
2017-12-22 22:42:00 +01:00
try:
obj.save()
except IntegrityError:
2018-11-21 21:49:49 +01:00
error = APIHybridError(status_code=400, message=_('Duplicate entry.'))
2017-12-22 22:42:00 +01:00
else:
if form.redirect_slugs is not None:
for slug in form.add_redirect_slugs:
obj.redirects.create(slug=slug)
2017-06-18 22:46:50 +02:00
2017-12-22 22:42:00 +01:00
for slug in form.remove_redirect_slugs:
obj.redirects.filter(slug=slug).delete()
2016-09-26 13:32:05 +02:00
2017-12-22 22:42:00 +01:00
form.save_m2m()
2018-11-21 21:49:49 +01:00
return APIHybridMessageRedirectResponse(
level='success',
message=_('Object was successfully saved.'),
redirect_to=ctx['back_url']
)
2017-07-07 15:32:41 +02:00
else:
2018-11-21 21:49:49 +01:00
error = APIHybridError(status_code=403, message=_('You can not edit changes on this changeset.'))
2017-07-07 15:32:41 +02:00
2016-09-26 13:32:05 +02:00
else:
form = model.EditorForm(instance=obj, request=request, space_id=space_id,
force_geometry_editable=force_geometry_editable)
2016-09-26 13:32:05 +02:00
ctx.update({
2016-09-26 13:32:05 +02:00
'form': form,
})
2018-11-21 21:49:49 +01:00
return APIHybridFormTemplateResponse('editor/edit.html', ctx, form=form, error=error)
2017-05-16 17:45:56 +02:00
def get_visible_spaces(request):
cache_key = 'editor:visible_spaces:%s:%s' % (
request.changeset.raw_cache_key_by_changes,
AccessPermission.cache_key_for_request(request, with_update=False)
)
visible_spaces = cache.get(cache_key, None)
if visible_spaces is None:
Space = request.changeset.wrap_model('Space')
visible_spaces = tuple(Space.qs_for_request(request).values_list('pk', flat=True))
cache.set(cache_key, visible_spaces, 900)
return visible_spaces
def get_visible_spaces_kwargs(model, request):
kwargs = {}
if hasattr(model, 'target_space'):
visible_spaces = get_visible_spaces(request)
kwargs['target_space_id__in'] = visible_spaces
if hasattr(model, 'origin_space'):
kwargs['origin_space_id__in'] = visible_spaces
return kwargs
2018-11-21 22:21:44 +01:00
@sidebar_view(api_hybrid=True)
2017-10-27 17:08:36 +02:00
@etag(etag_func)
2017-06-11 14:43:14 +02:00
def list_objects(request, model=None, level=None, space=None, explicit_edit=False):
2018-11-21 22:21:44 +01:00
resolver_match = getattr(request, 'sub_resolver_match', request.resolver_match)
if not resolver_match.url_name.endswith('.list'):
2017-05-16 17:45:56 +02:00
raise ValueError('url_name does not end with .list')
model = request.changeset.wrap_model(model)
Level = request.changeset.wrap_model('Level')
Space = request.changeset.wrap_model('Space')
can_edit = request.changeset.can_edit(request)
2018-11-20 22:54:29 +01:00
can_create = request.user_permissions.can_access_base_mapdata and can_edit
2017-05-16 17:45:56 +02:00
ctx = {
'path': request.path,
'model_name': model.__name__.lower(),
'model_title': model._meta.verbose_name,
'model_title_plural': model._meta.verbose_name_plural,
'explicit_edit': explicit_edit,
2018-11-20 22:54:29 +01:00
'can_create': can_create,
2017-05-16 17:45:56 +02:00
}
2017-05-19 15:23:00 +02:00
queryset = model.objects.all().order_by('id')
if hasattr(model, 'q_for_request'):
queryset = queryset.filter(model.q_for_request(request))
2017-05-19 16:34:02 +02:00
reverse_kwargs = {}
2017-05-19 15:23:00 +02:00
2017-06-11 14:43:14 +02:00
if level is not None:
reverse_kwargs['level'] = level
2017-07-15 16:31:20 +02:00
level = get_object_or_404(Level.objects.filter(Level.q_for_request(request)), pk=level)
queryset = queryset.filter(level=level).defer('geometry')
2017-05-16 17:45:56 +02:00
ctx.update({
2017-06-11 14:43:14 +02:00
'back_url': reverse('editor.levels.detail', kwargs={'pk': level.pk}),
'back_title': _('back to level'),
'levels': Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
2017-06-11 14:43:14 +02:00
'level': level,
2018-11-21 22:21:44 +01:00
'level_url': resolver_match.url_name,
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?level='+str(level.primary_level_pk)
if request.user_permissions.can_access_base_mapdata else None),
2017-05-19 16:34:02 +02:00
})
elif space is not None:
reverse_kwargs['space'] = space
sub_qs = Space.objects.filter(Space.q_for_request(request)).select_related('level').defer('geometry')
space = get_object_or_404(sub_qs, pk=space)
queryset = queryset.filter(space=space).filter(**get_visible_spaces_kwargs(model, request))
try:
model._meta.get_field('geometry')
except FieldDoesNotExist:
pass
else:
queryset = queryset.defer('geometry')
try:
model._meta.get_field('origin_space')
except FieldDoesNotExist:
pass
else:
queryset = queryset.select_related('origin_space')
try:
model._meta.get_field('target_space')
except FieldDoesNotExist:
pass
else:
queryset = queryset.select_related('target_space')
2017-05-19 16:34:02 +02:00
ctx.update({
'levels': Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
2017-06-11 14:43:14 +02:00
'level': space.level,
'level_url': 'editor.spaces.list',
'space': space,
2017-06-11 14:43:14 +02:00
'back_url': reverse('editor.spaces.detail', kwargs={'level': space.level.pk, 'pk': space.pk}),
2017-05-16 17:45:56 +02:00
'back_title': _('back to space'),
2018-11-20 22:54:29 +01:00
'geometry_url': ('/api/editor/geometries/?space='+str(space.pk)
if request.user_permissions.can_access_base_mapdata else None),
2017-05-16 17:45:56 +02:00
})
else:
ctx.update({
'back_url': reverse('editor.index'),
'back_title': _('back to overview'),
})
2018-11-21 22:21:44 +01:00
edit_url_name = resolver_match.url_name[:-4]+('detail' if explicit_edit else 'edit')
2017-05-19 16:34:02 +02:00
for obj in queryset:
reverse_kwargs['pk'] = obj.pk
obj.edit_url = reverse(edit_url_name, kwargs=reverse_kwargs)
reverse_kwargs.pop('pk', None)
2017-05-19 15:23:00 +02:00
ctx.update({
2018-11-21 22:21:44 +01:00
'create_url': reverse(resolver_match.url_name[:-4] + 'create', kwargs=reverse_kwargs),
2017-05-19 15:23:00 +02:00
'objects': queryset,
})
2018-11-21 22:21:44 +01:00
return APIHybridTemplateContextResponse('editor/list.html', ctx,
fields=('can_create', 'create_url', 'objects'))
2017-07-15 16:31:20 +02:00
def connect_nodes(request, active_node, clicked_node, edge_settings_form):
2018-11-20 22:54:29 +01:00
if not request.user_permissions.can_access_base_mapdata:
raise PermissionDenied
2017-12-19 17:00:06 +01:00
changeset_exceeded = get_changeset_exceeded(request)
graphedge_changes = {}
if changeset_exceeded:
graphedge_changes = request.changeset.get_changed_objects_by_model('GraphEdge')
2017-07-27 13:53:39 +02:00
new_connections = []
new_connections.append((active_node, clicked_node, False))
if not edge_settings_form.cleaned_data['oneway']:
new_connections.append((clicked_node, active_node, True))
instance = edge_settings_form.instance
for from_node, to_node, is_reverse in new_connections:
existing = from_node.edges_from_here.filter(to_node=to_node).first()
2017-12-19 17:00:06 +01:00
if changeset_exceeded and (not existing or existing.pk not in graphedge_changes):
messages.error(request, _('Could not edit edge because your changeset is full.'))
return
if existing is None:
instance.pk = None
instance.from_node = from_node
instance.to_node = to_node
instance.save()
messages.success(request, _('Reverse edge created.') if is_reverse else _('Edge created.'))
elif existing.waytype == instance.waytype and existing.access_restriction == instance.access_restriction:
2017-07-27 13:53:39 +02:00
existing.delete()
messages.success(request, _('Reverse edge deleted.') if is_reverse else _('Edge deleted.'))
else:
existing.waytype = instance.waytype
existing.access_restriction = instance.access_restriction
existing.save()
messages.success(request, _('Reverse edge overwritten.') if is_reverse else _('Edge overwritten.'))
2017-07-15 16:31:20 +02:00
@sidebar_view
2017-10-27 17:08:36 +02:00
@etag(etag_func)
2017-07-15 16:31:20 +02:00
def graph_edit(request, level=None, space=None):
2018-11-20 22:54:29 +01:00
if not request.user_permissions.can_access_base_mapdata:
raise PermissionDenied
2017-07-15 16:31:20 +02:00
Level = request.changeset.wrap_model('Level')
Space = request.changeset.wrap_model('Space')
2017-07-19 18:02:40 +02:00
GraphNode = request.changeset.wrap_model('GraphNode')
GraphEdge = request.changeset.wrap_model('GraphEdge')
2017-07-15 16:31:20 +02:00
can_edit = request.changeset.can_edit(request)
ctx = {
'path': request.path,
'can_edit': can_edit,
'levels': Level.objects.filter(Level.q_for_request(request), on_top_of__isnull=True),
'level_url': 'editor.levels.graph',
2017-07-15 16:31:20 +02:00
}
create_nodes = False
2017-07-15 16:31:20 +02:00
if level is not None:
level = get_object_or_404(Level.objects.filter(Level.q_for_request(request)), pk=level)
ctx.update({
'back_url': reverse('editor.levels.detail', kwargs={'pk': level.pk}),
'back_title': _('back to level'),
'level': level,
'geometry_url': '/api/editor/geometries/?level='+str(level.primary_level_pk),
})
elif space is not None:
queryset = Space.objects.filter(Space.q_for_request(request)).select_related('level').defer('geometry')
space = get_object_or_404(queryset, pk=space)
2017-11-25 20:32:05 +01:00
level = space.level
2017-07-15 16:31:20 +02:00
ctx.update({
'space': space,
'level': space.level,
2017-11-25 20:32:05 +01:00
'back_url': reverse('editor.spaces.detail', kwargs={'level': level.pk, 'pk': space.pk}),
2017-07-15 16:31:20 +02:00
'back_title': _('back to space'),
2017-11-25 20:32:05 +01:00
'parent_url': reverse('editor.levels.graph', kwargs={'level': level.pk}),
'parent_title': _('to level graph'),
2017-07-15 16:31:20 +02:00
'geometry_url': '/api/editor/geometries/?space='+str(space.pk),
})
create_nodes = True
2017-07-26 13:20:55 +02:00
if request.method == 'POST':
2017-12-19 17:00:06 +01:00
changeset_exceeded = get_changeset_exceeded(request)
graphnode_changes = {}
if changeset_exceeded:
graphnode_changes = request.changeset.get_changed_objects_by_model('GraphNode')
if request.POST.get('delete') == '1':
# Delete this graphnode!
node = get_object_or_404(GraphNode, pk=request.POST.get('pk'))
2017-12-19 17:00:06 +01:00
if changeset_exceeded and node.pk not in graphnode_changes:
messages.error(request, _('You can not delete this graph node because your changeset is full.'))
return redirect(request.path)
if request.POST.get('delete_confirm') == '1':
with request.changeset.lock_to_edit(request) as changeset:
if changeset.can_edit(request):
node.edges_from_here.all().delete()
node.edges_to_here.all().delete()
node.delete()
else:
messages.error(request, _('You can not edit changes on this changeset.'))
return redirect(request.path)
messages.success(request, _('Graph Node was successfully deleted.'))
return redirect(request.path)
return render(request, 'editor/delete.html', {
'model_title': GraphNode._meta.verbose_name,
'pk': node.pk,
'obj_title': node.title
})
2017-11-25 20:32:05 +01:00
permissions = AccessPermission.get_for_request(request) | set([None])
2017-07-26 13:52:23 +02:00
edge_settings_form = GraphEdgeSettingsForm(instance=GraphEdge(), request=request, data=request.POST)
graph_action_form = GraphEditorActionForm(request=request, allow_clicked_position=create_nodes,
2017-07-26 13:20:55 +02:00
data=request.POST)
2017-08-06 16:52:08 +02:00
if edge_settings_form.is_valid() and graph_action_form.is_valid():
2017-07-26 15:28:08 +02:00
goto_space = graph_action_form.cleaned_data['goto_space']
if goto_space is not None:
return redirect(reverse('editor.spaces.graph', kwargs={'space': goto_space.pk}))
2017-07-26 14:39:15 +02:00
set_active_node = False
2017-07-26 13:52:23 +02:00
active_node = graph_action_form.cleaned_data['active_node']
clicked_node = graph_action_form.cleaned_data['clicked_node']
clicked_position = graph_action_form.cleaned_data.get('clicked_position')
if clicked_node is not None and clicked_position is None:
if active_node is None:
2017-11-25 11:35:45 +01:00
active_node = clicked_node
2017-07-27 11:57:23 +02:00
set_active_node = True
elif active_node == clicked_node:
2017-07-27 11:57:23 +02:00
active_node = None
set_active_node = True
else:
2017-07-27 12:01:49 +02:00
with request.changeset.lock_to_edit(request) as changeset:
if changeset.can_edit(request):
connect_nodes(request, active_node, clicked_node, edge_settings_form)
active_node = clicked_node if edge_settings_form.cleaned_data['activate_next'] else None
set_active_node = True
2017-07-27 12:01:49 +02:00
else:
messages.error(request, _('You can not edit changes on this changeset.'))
2017-07-27 11:57:23 +02:00
elif (clicked_node is None and clicked_position is not None and
active_node is None and space.geometry.contains(clicked_position)):
2017-12-19 17:00:06 +01:00
if changeset_exceeded:
messages.error(request, _('You can not add graph nodes because your changeset is full.'))
return redirect(request.path)
with request.changeset.lock_to_edit(request) as changeset:
if changeset.can_edit(request):
node = GraphNode(space=space, geometry=clicked_position)
node.save()
messages.success(request, _('New graph node created.'))
2017-11-25 11:35:45 +01:00
active_node = None
set_active_node = True
else:
messages.error(request, _('You can not edit changes on this changeset.'))
2017-07-26 13:52:23 +02:00
2017-07-26 14:39:15 +02:00
if set_active_node:
connections = {}
2017-11-25 20:32:05 +01:00
if active_node:
for self_node, other_node in (('from_node', 'to_node'), ('to_node', 'from_node')):
conn_qs = GraphEdge.objects.filter(Q(**{self_node+'__pk': active_node.pk}))
conn_qs = conn_qs.select_related(other_node+'__space', other_node+'__space__level',
'waytype', 'access_restriction')
2017-11-25 20:32:05 +01:00
for edge in conn_qs:
edge.other_node = getattr(edge, other_node)
if (edge.other_node.space.access_restriction_id not in permissions
or edge.other_node.space.level.access_restriction_id not in permissions):
continue
connections.setdefault(edge.other_node.space_id, []).append(edge)
connections = sorted(
connections.values(),
key=lambda c: (c[0].other_node.space.level == level,
c[0].other_node.space == space,
c[0].other_node.space.level.base_altitude)
)
2017-07-26 14:39:15 +02:00
ctx.update({
'set_active_node': set_active_node,
'active_node': active_node,
2017-11-25 20:32:05 +01:00
'active_node_connections': connections,
2017-07-26 14:39:15 +02:00
})
2017-07-26 13:20:55 +02:00
else:
edge_settings_form = GraphEdgeSettingsForm(request=request)
graph_action_form = GraphEditorActionForm(request=request, allow_clicked_position=create_nodes)
2017-07-15 16:31:20 +02:00
2017-07-19 18:02:40 +02:00
ctx.update({
2017-07-26 13:20:55 +02:00
'edge_settings_form': edge_settings_form,
'graph_action_form': graph_action_form,
'create_nodes': create_nodes,
2017-07-19 18:02:40 +02:00
})
2017-07-15 16:31:20 +02:00
return render(request, 'editor/graph.html', ctx)
def sourceimage(request, filename):
if not request.user.is_superuser:
raise PermissionDenied
if not can_access_editor(request):
return PermissionDenied
try:
return HttpResponse(open(os.path.join(settings.SOURCES_ROOT, filename), 'rb'),
content_type=mimetypes.guess_type(filename)[0])
except FileNotFoundError:
raise Http404