138
authorization = LayerDjangoAuthorization()
always_return_data = False
def dehydrate_service_editable(self, bundle):
return bundle.obj.service_editable
def dehydrate_attributes(self, bundle):
bundle.obj.update_attributes()
return json.loads(bundle.obj.attributes)
def dehydrate(self, bundle):
bundle.data['service'] = {'attributes': [], 'editable': False, 'id': None,
'resource_uri': None, 'time': None, 'url': None}
try:
service_title = bundle.obj.content_object.title
except AttributeError:
service_title = bundle.data['name']
bundle.data['service_title'] = service_title
if bundle.obj.content_object:
try:
bundle.data['time'] = bundle.obj.content_object.time
except AttributeError:
bundle.data['time'] = False
bundle.data['service'] = {'editable': bundle.data['editable'], 'id':
int(bundle.data['content_object'].split('/')[-2]),
'resource_uri': bundle.data['content_object'],
'time': bundle.data['time'],
'title': bundle.data['service_title'],
'attributes': [], 'url': None}
return bundle
def get_bundle_with_child_data(self, layer, request, objects):
data = {
'title': layer.title,
'path': [],
'group_id': layer.id,
'layer_id': layer.id,
'visible': True,
'sublayers': [self.get_bundle_with_child_data(child, request, objects)
for child in objects if child.parent == layer]
}
try:
if not layer.is_group:
data['layer_type'] = layer.geom_type if layer.geom_type else
layer.service_type
except layer.LayerBadPropertyException:
data['layer_type'] = None
bundle = self.build_bundle(data=data, obj=layer, request=request)
return self.full_dehydrate(bundle, for_list=True)
def get_list(self, request, **kwargs):
project__name = Project.objects.get(name=request.GET['project__name']).slug
data = get_cache(CacheKeys.LAYER_TREE % project__name)
if data:
return HttpResponse(content=data.encode('utf-8'),
content_type='application/json', status=200)
base_bundle = self.build_bundle(request=request)
139
objects = self.obj_get_list(bundle=base_bundle,
**self.remove_api_resource_names(kwargs))
sorted_objects = self.apply_sorting(objects, options=request.GET)
paginator = self._meta.paginator_class(
request.GET, sorted_objects,
resource_uri=self.get_resource_uri(), limit=self._meta.limit,
max_limit=self._meta.max_limit,
collection_name=self._meta.collection_name
)
to_be_serialized = paginator.page()
objects = sorted(objects, key=lambda k: k.order)
bundles = []
for obj in [obj for obj in objects if not obj.parent]:
try:
bundle = self.get_bundle_with_child_data(layer=obj, request=request,
objects=objects)
bundles.append(bundle)
except Exception as e:
errors = to_be_serialized.get("errors", [])
errors.append({"layer": obj.title, "error": e})
to_be_serialized["errors"] = errors
to_be_serialized[self._meta.collection_name] = bundles
response = self.create_response(request, to_be_serialized)
GlobalCache.objects.create(key=CacheKeys.LAYER_TREE % project__name,
cache=(response.content.decode('utf-8')))
return response
def obj_create(self, bundle, **kwargs):
# Слой верхнего уровня всегда виртуальный,
# используем его только для сохранения порядка слоев первого уровня
project__name = bundle.data['project'].split('/')[-2]
layer_tree = bundle.request.body.decode('utf-8')
gc, created = GlobalCache.objects.get_or_create(
key=CacheKeys.LAYER_TREE % project__name,
defaults={'cache': json.dumps({'objects': [],'meta': {'total_count':
0,'limit': 0,'offset': 0}})})
if not gc.layer_tree(layer_tree):
return bundle
gc.layer_tree_del(layer_tree)
if bundle.data.get('layer_type', None) == 'virtual':
cache, changed = self.save_children(None, bundle.data['sublayers'], gc)
if changed:
gc.cache = json.dumps({'groups': cache})
gc.save()
else:
parent_layer = self.create_layer_object(bundle.data, None)
self.save_children(parent_layer, bundle.data['sublayers'], gc)
validate_attributes.apply_async()
return bundle
def obj_update(self, bundle, skip_errors=False, **kwargs):
project__name = bundle.data['project'].split('/')[-2]
bundle.data['attributes'] = json.dumps(bundle.data['attributes'])
140
# Удаляем лишние поля, т.к. у группы не может быть content_object
if bundle.data['is_group']:
del bundle.data['content_object']
del bundle.data['object_id']
bundle = super(LayerTreeResource, self).obj_update(bundle, **kwargs)
if 'sublayers' in bundle.data.keys():
gc = GlobalCache.objects.get(key=CacheKeys.LAYER_TREE % project__name)
cache, changed = self.save_children(bundle.obj, bundle.data['sublayers'],
gc)
if changed:
gc.cache = json.dumps({'groups': cache})
gc.save()
return bundle
def save_children(self, parent_layer, sublayers, gc, sublayers_cache=None):
changed = False
sublayers_cache = json.loads(gc.cache)['groups'] if not sublayers_cache else
sublayers_cache
sublayers_ids = [sublayer['id'] for sublayer in sublayers]
sublayers_cache_ids = [sublayer['id'] for sublayer in sublayers_cache]
if sublayers_ids != sublayers_cache_ids:
ids_add = list(set(sublayers_ids) - set(sublayers_cache_ids))
ids_delete = list(set(sublayers_cache_ids) - set(sublayers_ids))
if ids_delete:
sublayers_cache = list(filter(lambda x: x['id'] not in ids_delete,
sublayers_cache))
if ids_add:
[sublayers_cache.append(sublayer) for sublayer in sublayers if
sublayer['id'] in ids_add]
changed = True
for idx, sublayer in enumerate(sublayers):
if sublayer.get('resource_uri', None):
try:
sublayer_service = gc.service[sublayer['id']]
except KeyError:
sublayer_service = gc.service[str(sublayer['id'])] if
str(sublayer['id']) in gc.service else {}
fast_copy_s = copy.deepcopy(sublayer)
fast_copy_ss = copy.deepcopy(sublayer_service)
if 'service' in fast_copy_s:
del fast_copy_s['service']
if 'service' in fast_copy_ss:
del fast_copy_ss['service']
if fast_copy_ss == fast_copy_s and not changed:
continue
sublayer_obj = Layer.objects.get(pk=sublayer['id'])
sublayer_obj.parent = parent_layer
sublayer_obj.title = sublayer['title']
sublayers_cache[idx]['title'] = sublayer['title']
sublayer_obj.visible = sublayer['visible']
sublayers_cache[idx]['visible'] = sublayer['visible']
sublayer_obj.editable = sublayer['editable']
sublayers_cache[idx]['editable'] = sublayer['editable']
sublayer_obj.popup_image = sublayer['popup_image']
sublayers_cache[idx]['popup_image'] = sublayer['popup_image']
sublayer_obj.popup_chart = sublayer['popup_chart']
sublayers_cache[idx]['popup_chart'] = sublayer['popup_chart']
sublayer_obj.crowdsource = sublayer['crowdsource']
141
sublayers_cache[idx]['crowdsource'] = sublayer['crowdsource']
sublayer_obj.crowdsource_btn_text = sublayer['crowdsource_btn_text']
sublayers_cache[idx]['crowdsource_btn_text'] =
sublayer['crowdsource_btn_text']
if 'attributes' in sublayer.keys():
attrs = json.dumps(sublayer['attributes']) if
isinstance(sublayer['attributes'], list) else sublayer['attributes']
sublayer_obj.attributes = attrs
sublayer_obj.searchable = sublayer['searchable']
sublayers_cache[idx]['searchable'] = sublayer['searchable']
sublayer_obj.order = idx
sublayer_obj.save()
changed = True
if len(sublayer['sublayers']):
sublayers_cache[idx]['sublayers'] =
self.save_children(sublayer_obj, sublayer['sublayers'], gc,
sublayers_cache[idx]['sublayers'])[0]
else:
sublayer['order'] = idx
try:
sublayer_obj = self.create_layer_object(sublayer, parent_layer)
except KeyError:
del sublayers_cache[idx]
continue
sublayer_obj.parent = parent_layer
sublayer_obj.save()
sublayer_to_cache = copy.deepcopy(sublayer)
if sublayer.get('service') and sublayer['service']['url'] and not
sublayer['service'].get('map'):
sublayer_to_cache['content_object'] = '/data-
manager/api/v1/%sservice/%s/' % \
(sublayer['service']['type'],
sublayer['service']['id'])
sublayer_to_cache['id'] = sublayer_obj.id
sublayer_to_cache['layer_id'] = sublayer_obj.id
sublayer_to_cache['layer_type'] = 'raster'
sublayer_to_cache['name'] = sublayer['service']['real_name']
sublayer_to_cache['object_id'] = sublayer['service']['id']
sublayer_to_cache['parameters'] = ''
sublayer_to_cache['resource_uri'] = '/api/v1/layertree/%s/' %
sublayer_obj.id
sublayer_to_cache['service_title'] =
sublayer['service']['real_name']
sublayer_to_cache['wms_title'] = sublayer['service']['title']
else:
if sublayer['is_group']:
sublayer_to_cache['object_id'] = None
sublayer_to_cache['parameters'] = ""
sublayer_to_cache['content_object'] = None
sublayer_to_cache['name'] = None
sublayer_to_cache['service'] = {'url': None, 'attributes': [],
'editable': False,
'resource_uri': None, 'id': None}
else:
service_model =
get_cartoservice_model(sublayer['service']['type'])
service =
service_model.objects.get(id=sublayer['service']['id'])
sublayer_to_cache['object_id'] = sublayer_obj.object_id
sublayer_to_cache['parameters'] = sublayer_obj.parameters
142
sublayer_to_cache['content_object'] =
'/cartoservice/api/v1/%s/%s/' % (sublayer['service']['type'], service.id)
sublayer_to_cache['name'] = sublayer_obj.name
sublayer_to_cache['service'] = {'id': service.id, 'url': None,
'editable': service.editable,
'title': service.title,
'resource_uri':
'/cartoservice/api/v1/%s/%s/' % (
sublayer['service']['type'],
service.id)}
if 'time' in service.__dict__:
sublayer_to_cache['service']['time'] = service.time
sublayer_to_cache['layer_type'] = service.get_geom_type()
sublayer_to_cache['service_title'] = None
sublayer_to_cache['wms_title'] = None
sublayer_to_cache['path'] = []
sublayer_to_cache['id'] = sublayer_obj.id
sublayer_to_cache['resource_uri'] = '/api/v1/layertree/%s/' %
sublayer_obj.id
sublayer_to_cache['group_id'] = parent_layer.id if parent_layer else
sublayer_obj.id
sublayer_to_cache['layer_id'] = sublayer_obj.id
changed = True
del sublayers_cache[idx]
sublayers_cache.insert(idx, sublayer_to_cache)
if len(sublayer['sublayers']):
sublayers_cache[idx]['sublayers'] =
self.save_children(sublayer_obj, sublayer['sublayers'], gc,
sublayers_cache[idx]['sublayers'])[0]
return sublayers_cache, changed
def create_layer_object(self, layer_data, parent_layer):
data = copy.deepcopy(layer_data)
# Получаем id проекта из URI
project_id = data['project'].rsplit('/')[-2]
data['project'] = Project.objects.get(slug=project_id)
data['parent'] = parent_layer
if not data['is_group']:
# Слой из картосервиса
if data['service'].get('internal', None):
data['content_type'] =
ContentType.objects.get(app_label='cartoservice',
model=data['service']['modelName'])
# Внешний слой из дата менеджера
else:
data['content_type'] =
ContentType.objects.get(app_label='data_manager',
model=data['service']['modelName'])
data['name'] = data['service']['real_name']
data['wms_title'] = data['service']['title']
data['object_id'] = data['service']['id']
data['content_object'] =
data['content_type'].get_object_for_this_type(pk=data['object_id'])
# Получение атрибутов слоя
if 'attributes' in data.keys():
143
data['attributes'] = json.dumps(data['attributes'])
else:
data['attributes'] = json.dumps([])
# Удаляем лишние ключи из словаря
keys_to_delete = set(data.keys()) - set(f.name for f in
Layer._meta.get_fields())
for key in keys_to_delete:
del data[key]
# Удаляем id, так как он автоматически добавляется на фронте
data.pop('id', None)
return Layer.objects.create(**data)
def obj_delete(self, bundle, **kwargs):
response = super(LayerTreeResource, self).obj_delete(bundle, **kwargs)
if bundle.obj.content_object:
co = bundle.obj.content_object
GlobalCache.objects.get(key=CacheKeys.GET_SERVICES).update_service(service_serializer(c
o, co.get_type))
return response
class ProjectPermissionResource(ModelResource):
id = IntegerField(attribute='id')
type = CharField(attribute='type')
project = fields.ForeignKey(ProjectResource, 'project', full=False)
group = fields.ForeignKey(GroupResource, 'group', full=False, null=True,
blank=True)
user = fields.ForeignKey(UserResource, 'user', full=False, null=True, blank=True)
class Meta(GeoanalitikaBaseModelResource.Meta):
object_class = ProjectPermission
queryset = ProjectPermission.objects.all()
allowed_methods = ['get', 'put', 'patch', 'delete']
filtering = {
'project': ALL_WITH_RELATIONS,
'id': ('exact', 'iexact')
}
authorization = ProjectPermissionDjangoAuthorization()
def dehydrate(self, bundle):
if bundle.obj.group:
bundle.data['members'] = bundle.obj.group.user_set.count()
bundle.data['name'] = str(bundle.obj.group)
else:
bundle.data['name'] = str(bundle.obj.user)
return bundle
def get_list(self, request, **kwargs):
if request.GET.get('project__slug'):
data = get_cache(CacheKeys.PROJECT_PERMS % request.GET['project__slug'])
if data:
return HttpResponse(content=data.encode('utf-8'),
content_type='application/json', status=200)
data = super(ProjectPermissionResource, self).get_list(request, **kwargs)
if request.GET.get('project__slug'):
GlobalCache.objects.create(key=CacheKeys.PROJECT_PERMS %
request.GET['project__slug'],
144
cache=data.content.decode('utf-8'))
return data
def patch_list(self, request, **kwargs):
project__slug = request.GET['project__slug']
gc, created = GlobalCache.objects.get_or_create(
key=CacheKeys.PROJECT_PERMS % project__slug,
defaults={'cache': json.dumps({'objects': [],'meta': {'total_count':
0,'limit': 0,'offset': 0}})}
)
cache = json.loads(gc.cache)
perms = json.loads(request.body.decode('utf-8'))
perms_shortly = [{key: value for key, value in perm.items() if key !=
'layerPermissions'} for perm in perms['objects']]
template = {'deleted_objects': perms['deleted_objects'], 'objects': []}
if cache['objects'] != perms_shortly:
ids_new = [perm['id'] for perm in perms['objects'] if 'id' in perm]
ids_exists = [perm['id'] for perm in cache['objects']]
ids_added = list(set(ids_new) - set(ids_exists))
template['objects'] = [perm for perm in perms['objects'] if 'id' not in
perm or perm['id'] in ids_added]
ids_detail_check = list(set(ids_new) - set(ids_added))
for i, perm in enumerate(perms_shortly):
if perm.get('id') in ids_detail_check and perm !=
gc.service[str(perm['id'])]:
template['objects'].append(perms['objects'][i])
kwargs['body'] = json.dumps(template).encode('utf-8')
return TastyPiePatchList.patch_list(self, request, **kwargs)
def obj_create(self, bundle, **kwargs):
bundle = super(ProjectPermissionResource, self).obj_create(bundle, **kwargs)
project__slug = bundle.request.GET['project__slug']
GlobalCache.objects.get_or_create(
key=CacheKeys.PROJECT_PERMS % project__slug,
defaults={'cache': json.dumps({'objects': [],'meta': {'total_count':
0,'limit': 0,'offset': 0}})})[0]\
.project_perms_add(bundle.data, bundle.obj.id)
return bundle
def obj_update(self, bundle, skip_errors=False, **kwargs):
bundle = super(ProjectPermissionResource, self).obj_update(bundle, skip_errors,
**kwargs)
project__slug = bundle.request.GET['project__slug']
GlobalCache.objects.get(key=CacheKeys.PROJECT_PERMS %
project__slug).project_perm_change(bundle.data)
return bundle
def obj_delete(self, bundle, **kwargs):
project__slug = bundle.request.GET['project__slug']
GlobalCache.objects.get(key=CacheKeys.PROJECT_PERMS %
project__slug).project_perms_del(bundle.obj.id)
return super(ProjectPermissionResource, self).obj_delete(bundle, **kwargs)
class ProjectLayerPermissionResource(ModelResource):
id = IntegerField(attribute='id')
type = CharField(attribute='type')
layer = fields.ForeignKey(LayerTreeResource, 'layer', full=False)
project_permission = fields.ForeignKey(ProjectPermissionResource,
'project_permission', full=False)
145
class Meta(GeoanalitikaBaseModelResource.Meta):
object_class = ProjectLayerPermission
queryset = ProjectLayerPermission.objects.all()
allowed_methods = ['get', 'put', 'patch', 'delete']
filtering = {
'project_permission': ALL_WITH_RELATIONS
}
def dehydrate(self, bundle):
bundle.data['layer_id'] = bundle.obj.layer.id
bundle.data['layer_name'] = bundle.obj.layer.title
return bundle
def get_list(self, request, **kwargs):
if request.GET.get('project_permission__id'):
data = get_cache(CacheKeys.PROJECT_LAYER_PERM %
request.GET['project_permission__id'])
if data:
return HttpResponse(content=data.encode('utf-8'),
content_type='application/json', status=200)
data = super(ProjectLayerPermissionResource, self).get_list(request, **kwargs)
if request.GET.get('project_permission__id'):
GlobalCache.objects.create(key=CacheKeys.PROJECT_LAYER_PERM %
request.GET['project_permission__id'],
cache=data.content.decode('utf-8'))
return data
def patch_list(self, request, **kwargs):
body = json.loads(request.body.decode('utf-8'))
# Проверяем, не пришел ли запрос на сохранение одинаковых слоев в одну группу
perms_validate_dict = {}
for perm in body['objects']:
perm_id = perm['project_permission'].split('/')[-2]
if perm_id in perms_validate_dict:
if perm['layer_id'] in perms_validate_dict[perm_id]:
raise DoubleLayerException()
else:
perms_validate_dict[perm_id].append(perm['layer_id'])
else:
perms_validate_dict[perm_id] = [perm['layer_id']]
gc, created = GlobalCache.objects.get_or_create(
key=CacheKeys.PROJECT_LAYER_PERM_SLUG % request.GET['project__slug'],
defaults={'cache': json.dumps(body['objects'])}
)
cache = json.loads(gc.cache)
perms_dict = {perm['id']: perm for perm in cache if perm.get('id')}
perms_filtred = [obj for obj in body['objects'] if not obj.get('id') or
(obj['id'] in perms_dict and obj != perms_dict[obj['id']])]
if perms_filtred:
gc.cache = json.dumps(body['objects'])
gc.save()
perms_filtred_update = [obj for obj in perms_filtred if obj.get('id')]
if perms_filtred_update:
project_permission_ids = {}
for perm in perms_filtred_update:
perm_id = perm['project_permission'].split('/')[-2]
if perm_id in project_permission_ids:
project_permission_ids[perm_id].append(perm)
else:
project_permission_ids[perm_id] = [perm]
for perm_id in project_permission_ids:
146
gc = GlobalCache.objects.get(key=CacheKeys.PROJECT_LAYER_PERM %
perm_id)
cache = json.loads(gc.cache)
perms_filtred_update_dict = {perm['id']: perm for perm in
perms_filtred_update}
for i, perm_layer in enumerate(cache['objects']):
# Пропускаем те права, которые удаляются в этом запросе
if not perm_layer['id'] in perms_filtred_update_dict:
continue
if perm_layer != perms_filtred_update_dict[perm_layer['id']]:
cache['objects'][i] =
perms_filtred_update_dict[perm_layer['id']]
gc.cache = json.dumps(cache)
gc.save()
template = {
'objects': perms_filtred,
'deleted_objects': body['deleted_objects']
}
kwargs['body'] = json.dumps(template).encode('utf-8')
return TastyPiePatchList.patch_list(self, request, **kwargs)
def obj_create(self, bundle, **kwargs):
bundle = super(ProjectLayerPermissionResource, self).obj_create(bundle,
**kwargs)
id = bundle.obj.project_permission_id
gc = GlobalCache.objects.get(key=CacheKeys.PROJECT_LAYER_PERM_SLUG %
bundle.obj.project_permission.project.slug)
cache = json.loads(gc.cache)
for perm in cache:
if not perm.get('id') and perm == bundle.data:
perm['id'] = bundle.obj.id
perm['resource_uri'] = '/api/v1/projectlayerpermission/%s/' %
bundle.obj.id
break
gc.cache = json.dumps(cache)
gc.save()
GlobalCache.objects.get_or_create(
key=CacheKeys.PROJECT_LAYER_PERM % id,
defaults={'cache': {'meta': {'limit': 0, 'offset': 0, 'total_count': 0},
'objects': []}})[0]\
.project_layer_perms_add(bundle.data, bundle.obj.id)
return bundle
def obj_delete(self, bundle, **kwargs):
GlobalCache.objects.get(key=CacheKeys.PROJECT_LAYER_PERM %
bundle.obj.project_permission_id)\
.project_layer_perms_del(bundle.obj.id)
return super(ProjectLayerPermissionResource, self).obj_delete(bundle, **kwargs)