128
# render map
mr = MapRenderer(layers, bmap, width, height, bbox, layers_opacity)
m = mr.get_mapnik()
image = mapnik.Image(m.width, m.height)
mapnik.render(m, image)
return HttpResponse(image.tostring(format), 'image/' + format)
@has_access_to_project
def get_dictionaries(request, project, permission):
ids_string = request.GET.get('ids', None)
if not ids_string:
return HttpResponseBadRequest()
ids = [int(id) for id in ids_string.split(',')]
dicts = Dictionary.objects.filter(pk__in=ids)
response = []
for d in dicts:
entries = cache.get(DICT_CACHE_KEY % (request.user.id, d.id))
response.append({
'name': d.name,
'id': d.id,
'entries': entries if entries else [{'key': entry.key, 'value':
entry.value} for entry in d.entry_set.all()]
})
return HttpResponse(content=json.dumps({'dictionaries': response}),
content_type='application/json')
@require_GET
@has_access_to_project
def get_user(request, project, permission):
currentuser = {}
currentuser['name'] = None if not request.user.is_authenticated else
request.user.get_username()
currentuser['is_anonymous'] = False if request.user.is_authenticated else True
currentuser['can_edit'] = True if request.user.has_perm('change_project', project)
else ANONYMOUS_CAN_EDIT_MV
return HttpResponse(content=json.dumps(currentuser),
content_type='application/json')
@require_GET
@has_access_to_project
def get_min_max_attr(request, project, permission, layer_id, attr):
layer = Layer.objects.get(pk=layer_id, project=project)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
(min, max) = layer.get_sources()[0]['datasource'].get_min_max_attr_value(attr)
return HttpResponse(json.dumps({'min': min, 'max': max}), status=200,
content_type='application/json')
@has_access_to_project
def get_feature_count(request, project, permission):
129
if 'layers' in request.GET:
layer_ids = request.GET['layers'].split(',')
layers = project.layer_set.filter(id__in=layer_ids)
else:
layers = []
counts = {}
for layer in layers:
if not layer.get_user_permission(request.user)['view']:
continue
counts[layer.id] = layer.get_feature_count()[0]
return HttpResponse(content=json.dumps(counts), content_type='application/json')
@has_access_to_project
@require_http_methods(['GET'])
def get_time_bounds(request, project, permission, layer_id):
layer = Layer.objects.get(pk=layer_id)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
if not layer.time:
return HttpResponseBadRequest()
time_bounds = layer.get_time_bounds()
return HttpResponse(content=json.dumps({'start': time_bounds[0], 'end':
time_bounds[1]}), content_type='application/json')
@has_access_to_project
@require_http_methods(['GET'])
def get_timeline(request, project, permission, layer_id):
# expecting ISO 8601 strings
start = request.GET.get('start', None)
end = request.GET.get('end', None)
filter = request.GET.get('filter', None)
# conversion of ISO strings to datetime.date
if start:
start = datetime.datetime(*list(map(lambda x: int(x), start[:10].split('-'))))
if end:
end = datetime.datetime(*list(map(lambda x: int(x), end[:10].split('-'))))
layer = Layer.objects.get(pk=layer_id)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсутствует доступ к слою'}))
timeline = layer.get_timeline(start, end, filter)
intervals = []
month_dicts = []
if isinstance(timeline[0][0], datetime.date) and not isinstance(timeline[0][0],
datetime.datetime):
date = start.date() if start else timeline[0][0]
last_date = end.date() if end else timeline[-1][0]
else:
date = start if start else timeline[0][0]
last_date = end if end else timeline[-1][0]
130
month = date.month
while date <= last_date:
item_for_date = next((x for x in timeline if x[0] == date), None)
data_index = timeline.index(item_for_date) if item_for_date is not None else
None
objects_for_date = item_for_date[1] if item_for_date is not None else None
date_dict = {
'date': date.isoformat(),
'objects': objects_for_date,
'data_index': data_index
}
if date.month != month:
intervals.append(list(month_dicts))
month_dicts = []
month_dicts.append(date_dict)
date += datetime.timedelta(days=1)
month = date.month
else:
month_dicts.append(date_dict)
date += datetime.timedelta(days=1)
intervals.append(month_dicts)
response = {
'orig_data': list(map(lambda x: {'date': x[0].isoformat(), 'objects': x[1]},
timeline)),
'intervals': intervals
}
return HttpResponse(content=json.dumps(response), content_type='application/json')
@require_GET
@has_access_to_project
def add_layer(request, project, permission):
if not permission['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к редактированию проекта'}))
try:
source_id = int(request.GET.get('source_id', None))
name = request.GET.get('name', None)
title = request.GET.get('title', None)
if title is None:
title = name
source = get_object_or_404(Source, pk=source_id)
editable = False
if source.content_object._meta.model_name == 'database':
try:
schema, table = name.split('.')
except ValueError:
return HttpResponseBadRequest(json.dumps({'message': 'Ошибка при
добавлении: неверный формат, необходимо указать схему и таблицу через точку'}))
if not source.content_object.table_exists(schema, table):
if not source.content_object.view_exists(schema, table):
if not source.content_object.materialized_view_exists(schema,
table):
return HttpResponseBadRequest(json.dumps({'message': 'Ошибка
при добавлении: таблица не существует'}))
131
editable = source.content_object.editable(schema, table)
elif source.content_object._meta.model_name == 'folder':
if not
os.path.exists(os.path.join(source.content_object.get_path(source.name), name)):
return HttpResponseBadRequest(json.dumps({'message': 'Ошибка при
добавлении: файл не существует'}))
editable = source.content_object.editable(name)
layer = Layer.objects.create(content_object=source.content_object,
project=project, name=name, title=title, editable=editable, visible=False)
return HttpResponse(content=json.dumps(serialize_layer(layer)),
content_type='application/json')
except Exception as e:
return HttpResponseBadRequest(json.dumps({'message': 'Ошибка при добавлении: '
+ str(e)}))
@require_GET
@has_access_to_project
def transform_layer(request, project, permission):
if not permission['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к редактированию проекта'}))
layer_id = request.GET.get('layer_id', None)
type = request.GET.get('type', None)
layer = get_object_or_404(Layer, pk=int(layer_id), project=project)
if not layer.get_user_permission(request.user)['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
if type == 'wms':
layer = layer.transform_to_wms()
elif type == 'table':
layer = layer.transform_to_table()
return HttpResponse(content=json.dumps(serialize_layer(layer)),
content_type='application/json')
@require_POST
@csrf_exempt
@has_access_to_project
def copy_layer(request, project, permission, layer_id):
if not permission['change']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к редактированию проекта'}))
layer = get_object_or_404(Layer, pk=int(layer_id), project=project)
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
new_layer = layer.copy()
return HttpResponse(content=json.dumps(serialize_layer(new_layer)),
content_type='application/json')
@require_GET
@has_access_to_project
def get_quantile_attr(request, project, permission):
layer_id = request.GET['layer_id']
attr = request.GET['attr']
count = int(request.GET['count'])
layer = get_object_or_404(Layer, pk=int(layer_id), project=project)
132
if not layer.get_user_permission(request.user)['view']:
return HttpResponseBadRequest(
json.dumps({'message': 'Отсуствуют доступ к слою'}))
postgis_source = layer.get_sources()[0]['datasource']
attr_values = postgis_source.source.get_attribute_values({
'field': attr,
'is_not_null': True,
'full_table': postgis_source.get_sql_query()
})
np_arr = np.array(attr_values)
intervals = np.percentile(np_arr, np.delete(np.linspace(0, 100, count + 1),
0)).tolist()
response = {'intervals': intervals}
return HttpResponse(json.dumps(response), content_type='application/json')
@require_POST
@csrf_exempt
@has_access_to_project
def get_sql_filter(request, project, permission):
body_unicode = request.body.decode('utf-8')
body = json.loads(body_unicode)
data_filter = body['filter']
sql_filter = FilterMixin()._filter_to_sql(data_filter)
return HttpResponse(content=json.dumps({'sql_filter': sql_filter}),
content_type='application/json')
@require_GET
@has_access_to_project
def get_dynamic_layers(request, project, permissions):
response = [{'id': o.id, 'title': o.title, 'type': 'omnicomm'} for o in
OmnicommLayer.objects.filter(project=project)]
return HttpResponse(json.dumps(response), content_type='application/json',
status=200)
class OmnicommViews:
"""
Блок представлений по работе с динамическими слоями Omnicomm
"""
@staticmethod
@require_GET
@has_access_to_project
def get_layers(request, project, permissions, id):
layer = get_object_or_404(OmnicommLayer, id=id)
try:
layers = layer.get_layers()
except OmnicommException as e:
return HttpResponseServerError(e.args[0])
return HttpResponse(layers, content_type='application/json', status=200)
@staticmethod
@require_GET
def state(request, slug, id, terminal_id):
layer = get_object_or_404(OmnicommLayer, id=id)
try:
133
geojson = layer.state(terminal_id)
except OmnicommException as e:
return HttpResponseServerError(e.args[0])
return HttpResponse(geojson, content_type='application/json', status=200)
# -*- coding: utf-8 -*-
import copy
import json
import urllib
from django.http import HttpResponse
from django.contrib.contenttypes.models import ContentType
from guardian.shortcuts import assign_perm
from mptt.templatetags.mptt_tags import cache_tree_children
from tastypie.authorization import DjangoAuthorization
from tastypie.constants import ALL_WITH_RELATIONS
from tastypie.contrib.contenttypes.fields import GenericForeignKeyField
from tastypie.exceptions import Unauthorized
from tastypie.resources import ModelResource, fields
from tastypie.fields import CharField, BooleanField, IntegerField
from authentication.api import GroupResource, UserResource
from cartoservice.api import TMSResource, WFSResource, WMSResource, GeoJsonResource
from cartoservice.models import TMSService, WFSService, WMSService, GeoJsonService
from cartoservice.serializers import service_serializer
from data_manager.api import (ArcgisserviceResource, DatabaseResource,
FolderResource, GeoserverserviceResource,
SaikuserviceResource, WmsserviceResource,
WmtsserviceResource)
from data_manager.models import (Arcgisservice, Database, Folder,
Geoserverservice, Saikuservice, Wmsservice,
Wmtsservice)
from main.resources import GeoanalitikaBaseModelResource, MultiPartResource
from main.consts import CacheKeys
from main.models import GlobalCache
from main.utils import get_cache, get_cartoservice_model
from main.custom import TastyPiePatchList
from main.serializers import PrettyJSONSerializer
from .exceptions import DoubleLayerException
from .models import (BaseMap, Layer, Project, ProjectLayerPermission,
ProjectPermission)
from .serializers import basemap_serializer
from .tasks import validate_attributes
class ProjectDjangoAuthorization(DjangoAuthorization):
READ_PERM_CODE = 'view'
def read_list(self, object_list, bundle):
return [project for project in object_list if
project.get_user_permission(bundle.request.user)['view']]
def update_list(self, object_list, bundle):
return bool([project for project in object_list if
project.get_user_permission(bundle.request.user)['change']])
def update_detail(self, object_list, bundle):
return bool([project for project in object_list if
project.get_user_permission(bundle.request.user)['change']])
134
def delete_detail(self, object_list, bundle):
return bool([project for project in object_list if
project.get_user_permission(bundle.request.user)['delete']])
class ProjectPermissionDjangoAuthorization(DjangoAuthorization):
READ_PERM_CODE = 'view'
def check_user_perm(self, user, permission, obj_or_list):
return obj_or_list.project.get_user_permission(user)['view']
def read_list(self, object_list, bundle):
return [permission for permission in object_list
if
permission.project.get_user_permission(bundle.request.user)['delete']]
def update_list(self, object_list, bundle):
if len(object_list):
return bool(self.read_list(object_list, bundle))
return True
def update_detail(self, object_list, bundle):
if len(object_list):
return bool(self.read_list(object_list, bundle))
return True
def create_list(self, object_list, bundle):
if len(object_list):
return bool(self.read_list(object_list, bundle))
return True
def create_detail(self, object_list, bundle):
if len(object_list):
return bool(self.read_list(object_list, bundle))
return True
class LayerDjangoAuthorization(DjangoAuthorization):
def read_list(self, object_list, bundle):
if len(object_list) >= 1:
permission =
object_list[0].project.get_user_permission(bundle.request.user)
if not permission['view']:
raise Unauthorized('You are not allowed to access that resource.')
return object_list
def read_detail(self, object_list, bundle):
if len(object_list) >= 1:
permission =
object_list[0].project.get_user_permission(bundle.request.user)
if not permission['view']:
raise Unauthorized('You are not allowed to access that resource.')
return True
135
class ProjectResource(MultiPartResource, ModelResource):
id = CharField(attribute='id')
parameters = CharField(attribute='parameters')
cartometry_permission = CharField(attribute='cartometry_permission', null=True,
blank=True)
dashboard_permission = CharField(attribute='dashboard_permission', null=True,
blank=True)
diagram_permission = CharField(attribute='diagram_permission', null=True,
blank=True)
extent = CharField(attribute='extent')
name = CharField(attribute='name')
public = BooleanField(attribute='public')
slug = CharField(attribute='slug', blank=True)
type = CharField(attribute='type')
tabviewer_download_permission =
CharField(attribute='tabviewer_download_permission', null=True, blank=True)
preview = fields.FileField(attribute="preview", null=True, blank=True)
class Meta(GeoanalitikaBaseModelResource.Meta):
object_class = Project
queryset = Project.objects.all().order_by('name')
allowed_methods = ['get', 'post', 'put', 'delete']
limit = 0
# Позволяет писать в URL'e slug вместо pk
# при обращении к API
detail_uri_name = 'slug'
filtering = {
'name': ('exact', 'iexact'),
'slug': ('exact', 'iexact'),
'type': ('exact', 'iexact')
}
authorization = ProjectDjangoAuthorization()
def get_object_list(self, request):
projects = super(ProjectResource, self).get_object_list(request)
user = request.user
filtered_projects = [project.id for project in projects if
project.get_user_permission(user)['view']]
if filtered_projects:
return projects.filter(pk__in=filtered_projects)
else:
return projects.filter(public=True)
# Добавляем права на проект в JSON
def dehydrate(self, bundle):
# Фикс ошибки пересохранения проекта с картинкой с русским названием
# (кириллица переводится в URL-формат, tastypie не может распарсить такой
resource_uri,
# поэтому при выдаче перегоняем URL в юникод)
if bundle.data['preview']:
bundle.data['preview'] = urllib.parse.unquote(bundle.data['preview'])
user = bundle.request.user
project = Project.objects.get(pk=bundle.data['id'])
user_permission = project.get_user_permission(user)
can_edit = user_permission['change']
can_delete = user_permission['delete']
136
bundle.data['permissions'] = {'change_project': can_edit, 'delete_project':
can_delete}
base_map = bundle.obj.get_basemap()
if base_map is not None:
map_dict = basemap_serializer(base_map)
if base_map.basemap_set.all().exists():
map_dict['sublayers'] = [basemap_serializer(sublayer) for sublayer in
base_map.basemap_set.all()]
bundle.data['base_map'] = map_dict
bundle.data['parameters'] = json.loads(bundle.data['parameters'])
return bundle
def obj_create(self, bundle, **kwargs):
bundle.data['cartometry_permission'] = bundle.data.get('cartometry_permission')
bundle.data['dashboard_permission'] = bundle.data.get('dashboard_permission')
bundle.data['diagram_permission'] = bundle.data.get('diagram_permission', 'A')
bundle.data['tabviewer_download_permission'] =
bundle.data.get('tabviewer_download_permission')
# Конвертируем значение public,
# т.к. при сохранении проекта с картинкой
# приходит строка, а не булево значение
owner = None
if 'id' in bundle.data:
old_project = Project.objects.get(id=bundle.data['id'])
owner = old_project.owner
for field in old_project.__dict__:
if field != '_state' and field != 'id' and field not in bundle.data:
bundle.data[field] = old_project.__dict__[field]
if isinstance(bundle.data['public'], str):
bundle.data['public'] = bundle.data['public'] == 'true'
if not isinstance(bundle.data['parameters'], str):
bundle.data['parameters'] = json.dumps(bundle.data['parameters'])
bundle = super(ProjectResource, self).obj_create(bundle)
user = bundle.request.user
project = bundle.obj
project.owner = owner
# явно добавляем права на проект создателю проекта
if not bundle.data.get('id', None) and not user.is_superuser:
project_permission = ProjectPermission(user=user, type='F',
project=project)
project_permission.save()
if bundle.data.get('baseMapId', None):
project.default_basemap = BaseMap.objects.get(pk=bundle.data['baseMapId'])
else:
project.default_basemap = None
project.save(True)
# Даем права на просмотр и редактирование создателю проекта
assign_perm('change_project', user, project)
assign_perm('view_project', user, project)
return bundle
137
# Добавляем информацию о правах на добавление объекта в JSON
def alter_list_data_to_serialize(self, request, data):
user = request.user
if user.has_perm('map_viewer.add_project'):
data['can_add'] = True
else:
data['can_add'] = False
return data
class LayerTreeResource(ModelResource):
id = IntegerField(attribute='id')
title = CharField(attribute='title', null=True)
visible = BooleanField(attribute='visible', null=True)
object_id = IntegerField(attribute='object_id', null=True)
parameters = CharField(attribute='parameters', null=True)
name = CharField(attribute='name', null=True)
wms_title = CharField(attribute='wms_title', null=True)
is_group = BooleanField(attribute='is_group', null=True)
order = IntegerField(attribute='order', null=True)
editable = BooleanField(attribute='editable', null=True)
searchable = BooleanField(attribute='searchable', null=True)
popup_image = BooleanField(attribute='popup_image', null=True)
crowdsource = BooleanField(attribute='crowdsource', null=True)
popup_chart = BooleanField(attribute='popup_chart', null=True)
crowdsource_btn_text = CharField(attribute='crowdsource_btn_text', null=True)
project = fields.ForeignKey(ProjectResource, 'project', null=True, blank=True)
parent = fields.ForeignKey('self', 'parent', full=True, null=True, blank=True)
content_object = GenericForeignKeyField({
GeoJsonService: GeoJsonResource,
WMSService: WMSResource,
WFSService: WFSResource,
TMSService: TMSResource,
Wmsservice: WmsserviceResource,
Wmtsservice: WmtsserviceResource,
Arcgisservice: ArcgisserviceResource,
Geoserverservice: GeoserverserviceResource,
Folder: FolderResource,
Database: DatabaseResource,
Saikuservice: SaikuserviceResource
}, 'content_object', null=True, blank=True, full=False)
service_editable = fields.BooleanField('self', 'service_editable', use_in='all')
attributes = fields.ListField('self', 'attributes', use_in='detail')
class Meta(GeoanalitikaBaseModelResource.Meta):
object_class = Layer
serializer = PrettyJSONSerializer()
collection_name = 'groups'
queryset = Layer.objects.all().select_related('parent')
fields = ['id', 'object_id', 'visible', 'title', 'parent', 'name',
'attributes',
'is_group', 'order', 'wms_title', 'editable', 'popup_image',
'crowdsource', 'crowdsource_btn_text',
'searchable', 'parameters', 'popup_chart']
filtering = {
'project': ALL_WITH_RELATIONS,
'title': ('exact'),
}
allowed_methods = ['patch', 'delete', 'post', 'get', 'put']