118
layer_id_can_edit = []
else:
user_perm = [perm.layer.id for perm in
ProjectLayerPermission.objects.filter(
project_permission__project=project,
project_permission__user=request.user) if perm.type == 'E']
groups_perm = [perm.layer.id for perm in
ProjectLayerPermission.objects.filter(
project_permission__project=project,
project_permission__group__in=request.user.groups.all()) if
perm.type == 'E']
layers_id_edit = set(user_perm + groups_perm)
set_perms()
elif dashboard_perm == 'S':
set_perms(request.user.is_superuser)
elif dashboard_perm == 'O':
set_perms(request.user == project.owner)
elif dashboard_perm == 'V':
set_perms(permission['view'])
elif dashboard_perm == 'E':
set_perms(permission['change'])
elif dashboard_perm == 'F':
set_perms(permission['delete'])
context['dashboard_manage'] = layer_id_can_edit
# выгрузка csv из tab-viewer
tabviewer_download_perm = project.tabviewer_download_permission
if not tabviewer_download_perm:
tabviewer_download_perm =
site_config.project_tabviewer_download_default_permission
if permission['partial']:
context['tabviewer_download_enable'] = False
elif tabviewer_download_perm == 'S':
context['tabviewer_download_enable'] = request.user.is_superuser
elif tabviewer_download_perm == 'O':
context['tabviewer_download_enable'] = request.user == project.owner
elif tabviewer_download_perm == 'V':
context['tabviewer_download_enable'] = permission['view']
elif tabviewer_download_perm == 'E':
context['tabviewer_download_enable'] = permission['change']
elif tabviewer_download_perm == 'F':
context['tabviewer_download_enable'] = permission['delete']
else:
context['tabviewer_download_enable'] = False
# картометрический анализ
tools = json.loads(project.parameters).get('tools', {'router': True, 'cartometry':
True})
if tools['cartometry']:
cartometry_perm = project.cartometry_permission
if not cartometry_perm:
cartometry_perm = site_config.project_cartometry_default_permission
if request.user.is_anonymous or permission['partial']:
context['cartometry_enable'] = False
elif cartometry_perm == 'V':
context['cartometry_enable'] = permission['view']
elif cartometry_perm == 'E':
context['cartometry_enable'] = permission['change']
elif cartometry_perm == 'F':
context['cartometry_enable'] = permission['delete']
else:
119
context['cartometry_enable'] = False
else:
context['cartometry_enable'] = False
context['cartometry_limit'] = CARTOMETRIC_ANALYSIS_FEATURES_LIMIT
context['router_enable'] = tools['router']
if project.extent:
extent = project.getExtent(4326)
if 'p' in request.GET:
try:
permalink = ProjectPermalink.objects.get(pk=request.GET.get('p'),
project=project)
perm_extent = permalink.get_extent()
extent = perm_extent if perm_extent is not None else extent
except ProjectPermalink.DoesNotExist:
pass
context['extent'] = str(extent[1]) + ',' + str(extent[0]) + ',' +
str(extent[3]) + ',' + str(extent[2])
if 'iframe' in request.GET.keys():
context['expandLegend'] = bool(request.GET.get('expandLegend', False))
context['fullFeatureInfo'] = bool(request.GET.get('fullFeatureInfo',
site_config.mapviewer_iframe_full_feature_info))
return render(request, 'projects/plugins-iframe.html', context,
content_type='application/json')
elif request.user_agent.is_mobile or request.user_agent.is_tablet:
context['expandLegend'] = bool(request.GET.get('expandLegend', False))
context['fullFeatureInfo'] = bool(request.GET.get('fullFeatureInfo',
site_config.mapviewer_iframe_full_feature_info))
return render(request, 'projects/plugins-mobile.html', context,
content_type='application/json')
return render(request, 'projects/plugins.html', context,
content_type='application/json')
@csrf_exempt
@has_access_to_project
@require_http_methods(['POST'])
def add_permalink(request, project, permission):
body_unicode = request.body.decode('utf-8')
permalink = ProjectPermalink.objects.create(project=project, config=body_unicode)
url = '{}?p={}'.format(request.META['HTTP_REFERER'].split('?')[0], permalink.id)
return HttpResponse(json.dumps({'url': url}), content_type='application/json')
@csrf_exempt
@has_access_to_project
@require_http_methods(['GET', 'POST'])
def search(request, project, permission):
response = []
security_tag = get_user_security_tag(request.user)
if request.method == 'POST':
params = json.loads(request.body.decode('utf-8'))
else:
params = request.GET
filter = params.get('ID', None) or params.get('GEOMETRY', None)
120
object_filters = params.get('FILTERS', None)
layer_ids = params.get('LAYERS', None)
text = params.get('text', None)
if text:
text = unquote(text)
if layer_ids:
layer_ids = layer_ids.split(',')
layers = Layer.objects.filter(id__in=layer_ids, project=project,
is_group=False, searchable=True)
for layer in layers:
if not layer.get_user_permission(request.user)['view']:
continue
sources = layer.get_sources()
object_filter = object_filters.get(str(layer.id), None) if object_filters
else None
config = SiteConfiguration.get_solo()
if request.user_agent.is_mobile or request.user_agent.is_tablet:
limit = config.mapviewer_mobile_search_result_limit
else:
limit = config.mapviewer_search_result_limit
if limit == 0:
limit = None
for obj in sources:
model_name = obj['source'].content_object._meta.model_name
if 'datasource' in obj.keys():
datasource = obj['datasource']
if model_name in ['database', 'folder']:
k = str(layer.id)
if model_name == 'database':
v = obj['source'].content_object.geojson(
schema=obj['schema'],
table=obj['name'],
geom_field=datasource.get_geom_field_name(),
srid=datasource.srid,
modified_table=datasource.get_sql_query(use_materialized_view=True),
security_tag=security_tag,
filter=filter,
obj_filter=object_filter,
text=text,
limit=limit)
else:
v = obj['source'].content_object.geojson(
name=obj['name'],
filter=filter,
obj_filter=object_filter,
text=text,
limit=limit)
if v is not None:
response.append({k: v})
return HttpResponse(json.dumps(response), content_type='application/json')
@csrf_exempt
@has_access_to_project
@require_http_methods(['GET'])
121
def get_attachments(request, project, permission):
object_id = int(request.GET.get('pk'))
layer_id = int(request.GET.get('layer_id'))
response = {}
layer = get_object_or_404(Layer, pk=layer_id)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
files = File.objects.filter(layer_id=layer_id, object_id=object_id,
layer__project=project)
response['documents'] = list(
map(lambda f: {'title': f.title, 'url': get_host() + f.file.url, 'id': f.id},
files.filter(type='document')))
response['images'] = list(
map(lambda f: {'title': f.title, 'url': get_host() + f.file.url, 'id': f.id},
files.filter(type='image')))
return HttpResponse(json.dumps(response), content_type='application/json')
@csrf_exempt
@has_access_to_project
@require_http_methods(['GET'])
def get_feature_image(request, project, permission):
object_id = int(request.GET.get('pk'))
layer_id = int(request.GET.get('layer_id'))
layer = get_object_or_404(Layer, pk=layer_id)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
response = {}
files = File.objects.filter(layer_id=layer_id, object_id=object_id,
layer__project=project)
response['images'] = list(map(lambda f: {'title': f.title, 'url': get_host() +
f.file.url, 'id': f.id},
files.filter(type='image')))
return HttpResponse(json.dumps(response), content_type='application/json')
@has_access_to_project
def get_unique_from_field(request, project, permission):
'''
required GET parameters: layer, field
возвращает все уникальные параметры для заданного поля field и слоя layer
:param request:
:param slug:
:return:
'''
if sorted(request.GET.keys()) == sorted(['layer', 'field']):
layer = get_object_or_404(Layer, id=request.GET['layer'], project=project)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
sources = layer.get_sources()
if len(sources) == 1:
source = sources[0]
if (source['source'].content_object._meta.model_name == 'database'):
values =
source['source'].content_object.get_unique_values(source['schema'], source['name'],
122
request.GET['field'])
elif (source['source'].content_object._meta.model_name != 'folder'):
values = source['source'].content_object.get_unique_values(layer.name,
request.GET['field'])
else:
values =
source['source'].content_object.get_unique_values(source['name'], request.GET['field'])
context = {'data': values}
return HttpResponse(json.dumps(context), content_type='application/json')
else:
return HttpResponseBadRequest(json.dumps({'message': 'Данный слой не
поддерживает данный запрос'}))
else:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют обязательные или присутсвуют
недопустимые атрибуты'}))
@csrf_exempt
@has_access_to_project
def upload_file(request, project, permission):
if 'type' in request.POST.keys():
layer = get_object_or_404(Layer, pk=int(request.POST['layer']),
project=project)
user_layer_permission = layer.get_user_permission(request.user)
if not(layer.crowdsource or (request.user.is_authenticated and
user_layer_permission['view'])):
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
new_file = File.objects.create(object_id=request.POST['object_id'],
file=request.FILES['file'],
type=request.POST['type'],
title=str(request.FILES['file']),
layer=layer
)
data = {
'title': new_file.title,
'url': get_host() + new_file.file.url,
'id': new_file.id
}
return HttpResponse(json.dumps(data), content_type='application/json',
status=200)
return HttpResponseBadRequest()
@csrf_exempt
@has_access_to_project
def upload_files(request, project, permission):
if 'type' in request.POST.keys():
if request.POST['type'] in ('image', 'document'):
file_type = request.POST['type']
object_id = request.POST['object_id']
layer = Layer.objects.get(pk=int(request.POST['layer']), project=project)
user_layer_permission = layer.get_user_permission(request.user)
if not (layer.crowdsource or (request.user.is_authenticated and
user_layer_permission['view'])):
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
if layer.crowdsource:
123
for key in request.FILES:
File.objects.create(object_id=object_id,
file=request.FILES[key],
type=file_type,
title=str(request.FILES[key]),
layer=layer)
return HttpResponse(json.dumps({'message': 'Объект успешно создан'}),
status=200)
return HttpResponseBadRequest(json.dumps({'message': 'Не удалось создать объект'}))
@csrf_exempt
@login_required
@require_http_methods(['DELETE'])
@has_access_to_project
def delete_file(request, project, permission):
layer = get_object_or_404(Layer, pk=int(request.GET['layer']), project=project)
object_id = int(request.GET['object_id'])
file_id = int(request.GET['id'])
if not layer.get_user_permission(request.user)['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
try:
file = File.objects.get(object_id=object_id, id=file_id, layer=layer)
except File.DoesNotExist:
return HttpResponseBadRequest(json.dumps({'message': 'Файл не найден'}))
file.delete()
return HttpResponse(content=json.dumps({'message': 'Файл успешно удален'}),
status=204)
@csrf_exempt
@require_http_methods(['POST'])
@has_access_to_project
def create_or_update_geom_object(request, project, permission):
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
layer = get_object_or_404(Layer, pk=int(body['layer_id']), project=project)
if not layer.crowdsource and not layer.get_user_permission(request.user)['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствует доступ к слою'}))
if not (True if request.user.is_authenticated else ANONYMOUS_CAN_EDIT_MV) and not
layer.crowdsource:
return HttpResponseBadRequest(json.dumps({'message': 'Остутствуют права на
редактирование'}))
geom = body['geom']
input_attributes = body['attributes']
pk = body.get('pk', None)
try:
created_pk = layer.create_of_update_feature(geom=geom,
input_attributes=input_attributes, pk=pk)
update_extent(layer.id)
except Exception as e:
return HttpResponseBadRequest(json.dumps({'message': str(e)}))
return HttpResponse(json.dumps({'message': 'Объект успешно обновлен', 'pk':
created_pk}), status=200)
124
@csrf_exempt
@require_http_methods(['POST'])
@has_access_to_project
def create_or_update_geom_objects(request, project, permission):
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
features = body.get('features', [])
created_pks = []
errors = []
for feature in features:
try:
layer = get_object_or_404(Layer, pk=int(feature['layer_id']),
project=project)
if not layer.get_user_permission(request.user)['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
except Layer.DoesNotExist:
errors.append({'feature': feature,
"error": 'Слоя {} не
существует'.format(feature['layer_id'])})
if not (True if request.user.is_authenticated else ANONYMOUS_CAN_EDIT_MV) and
not layer.crowdsource:
errors.append({'feature': feature,
"error": 'Остутствуют права на редактирование слоя
{}'.format(feature['layer_id'])})
geom = feature['geom']
input_attributes = feature['attributes']
pk = feature.get('pk', None)
try:
created_pks.append(layer.create_of_update_feature(geom=geom,
input_attributes=input_attributes, pk=pk))
update_extent(layer.id)
except Exception as e:
errors.append({'feature': feature, "error": str(e)})
return HttpResponse(json.dumps({'message': 'Объекты успешно обновлены', 'pk':
created_pks, 'errors': errors}), status=200)
@csrf_exempt
@require_http_methods(['DELETE'])
@has_access_to_project
def delete_geom_object(request, project, permission):
if not (True if request.user.is_authenticated else ANONYMOUS_CAN_EDIT_MV):
return HttpResponseBadRequest(json.dumps({'message': 'Остутствуют права на
редактирование'}))
params = request.GET
layer = get_object_or_404(Layer, pk=int(params['layer_id']), project=project)
if not layer.get_user_permission(request.user)['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
pk = params['pk']
source = layer.content_object.get_editable_source()
if source is None:
125
return HttpResponseBadRequest(json.dumps({'message': 'Слой не поддерживает
редактирование'}))
database = source['source'].content_object
schema = source['schema']
table = source['name']
try:
security_tag = get_user_security_tag(request.user)
if security_tag is not None:
feature = database.get_feature(schema, table, pk)
errors = security_tag.validate(feature)
if errors:
return HttpResponseBadRequest(json.dumps(
{'message': 'Следующие атрибуты не соответствуют метки
безопасности: ' + ' , '.join(errors)}))
database.delete_feature(schema, table, pk)
create_journal_log(
'%s (%s)' % (str(layer), str(project)),
MV_EDIT_LAYER_DATA,
'Удалены данные из слоя',
str(request.user)
)
update_extent.apply_async((layer.id,))
update_attributes.apply_async((layer.id,))
return HttpResponse({'message': 'Объект удален'}, status=204)
except DatabaseError as e:
return HttpResponseBadRequest(json.dumps({'message': 'Ошибка при удалении
объекта: ' + str(e)}))
@csrf_exempt
@require_http_methods(['POST'])
@has_access_to_project
def split(request, project, permissions):
"""
Пример запроса
{"id": Layer ID, "obj_id": ID Резрезаемого объекта, "line": Линия разреза типа
GeoJson}
{"id": 1, "obj_id": 1, "line": {"type": "lineString", "coordinates": ""}}
"""
sql = ''
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
layer = get_object_or_404(Layer, pk=int(body['id']), project=project)
if not layer.crowdsource and not layer.get_user_permission(request.user)['change']:
return HttpResponseBadRequest(json.dumps({'message': 'Отсуствует доступ к
слою'}))
elif not (True if request.user.is_authenticated else ANONYMOUS_CAN_EDIT_MV) and not
layer.crowdsource:
return HttpResponseBadRequest(json.dumps({'message': 'Остутствуют права на
редактирование'}))
source = layer.content_object.get_sources()[0]
db = source['source'].content_object
pk = db.get_pk(source['schema'], source['name'])[0]
geom_column = db.get_geom_fields(source['schema'], source['name'])[0]
if 'point' in geom_column['type']:
126
return HttpResponseBadRequest(json.dumps({'message': 'Невозможно разделить
объект с типом геометри "Точка"'}))
columns = ['"' + column['name'] + '"' for column in
db.get_attributes(source['schema'], source['name']) if column['name'] != pk]
features = db._fetch_all_from_db(
'''SELECT {columns}
(
ST_Dump(
ST_Split(
"{geometry_field}",
ST_Transform(
ST_SetSrid(ST_GeomFromGeoJSON('{geom}'),4326),
{srs})
)
)
).geom
FROM "{table}" WHERE "{pk_field}"={id}''' \
.format(columns=(','.join(columns) + ',') if columns else '',
geometry_field=geom_column['column'],
geom=json.dumps(body['line']), table=source['name'],
srs=geom_column['srid'], pk_field=pk, id=body['obj_id'])
)
columns.append('"' + geom_column['column'] + '"')
if len(features) < 2:
return HttpResponseBadRequest(json.dumps({'message': 'Линия разреза не
пересекла ни одним объект'}))
for i, feature in enumerate(features):
feature = ["'" + str(col) + "'" if col else 'null' for col in feature]
feature[len(feature) - 1] = "ST_Multi('" + features[i][len(feature) - 1] + "')"
sql += '''INSERT INTO "{table}"({columns}) VALUES({values});''' \
.format(table=source['name'], columns=','.join(columns),
values=','.join(feature))
sql += '''DELETE FROM "{table}" WHERE "{pk_field}" = {id};'''\
.format(table=source['name'], pk_field=pk, id=body['obj_id'])
db._execute_sql(''.join(sql))
return HttpResponse(status=202)
@has_access_to_project
def legend(request, project, permission):
if 'layers' in request.GET:
layer_ids = request.GET['layers'].split(',')
layers = project.layer_set.filter(id__in=layer_ids)
else:
layers = []
styles = {}
for layer in layers:
if not layer.get_user_permission(request.user)['view']:
continue
leg = layer.get_legend()
if leg is not None:
styles[layer.id] = leg
return HttpResponse(content=json.dumps(styles), content_type='application/json')
@has_access_to_project
def get_project_layers_as_image(request, project, permission):
'''
Рендерит слои проекта в огромное, невероятно большое по своим масштабам и
127
величию изображение.
:param request: HttpRequest
:return: rendered image of some project's layers
GET parameters:
height - высота, по-умолчанию: 800;
width - ширина, по-умолчанию: 600;
base_background - базовая подложка, по-умолчанию: дефолтная для проекта;
layers - слои, которые будут включены в рендер, в порядке отображения, по-
умолчанию: включенные слои проекта с их параметрами;
layers_opacity - значения прозрачности слоев в соответствующем порядке;
extent - экстент,заданный пользователем экстент или по экстенту определенного
объекта, по-умолчанию: по экстенту проекта.
'''
height = request.GET.get('height', 600)
width = request.GET.get('width', 800)
base_map = request.GET.get('base_map', None)
extent = request.GET.get('extent', None)
format = request.GET.get('format', 'jpeg')
layers = request.GET.get('layers', None)
layers_opacity = request.GET.get('layers_opacity', None)
# get extent
if extent is not None:
bbox = ogr.CreateGeometryFromWkt(extent).GetEnvelope()
# elif extent_by:
else:
bbox = project.extent.extent
# get base_map
if base_map is None:
bmap = project.get_basemap().real_url
else:
try:
bmap = BaseMap.objects.get(slug=base_map).real_url
except BaseMap.DoesNotExist:
return HttpResponseBadRequest('Can\'t find base map with slug %s' %
base_map)
# get layers
if layers is None:
layers = project.layer_set.filter(visible=True)
else:
try:
layer_ids = [int(layer) for layer in layers.split(',')]
layers_dict = {layer.id: layer for layer in
list(project.layer_set.filter(id__in=layer_ids))}
layers = [layers_dict[layer_id] for layer_id in layer_ids]
except (TypeError, ValueError):
return HttpResponseBadRequest('Bad layers list')
# get layers opacity
if layers_opacity is not None:
try:
layers_opacity = [float(opacity) for opacity in layers_opacity.split(',')]
if len(layers_opacity) != len(layers):
return HttpResponseBadRequest('Length of layers_opacity must be same as
layers')
except (TypeError, ValueError):
return HttpResponseBadRequest('Bad layers opacity list')