def _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = models.DBSession.query(RestrictionArea.area, RestrictionArea.area.ST_SRID())
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(to_shape(ra))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
filter1_ = create_filter(self.request, cls, geom_attr)
ra = cascaded_union(collect_ra)
filter2_ = ga_func.ST_Contains(
from_shape(ra, use_srid),
getattr(cls, geom_attr)
)
filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
return proto.read(self.request, filter=filter_)
def _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = DBSession.query(RestrictionArea.area, RestrictionArea.area.ST_SRID())
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(to_shape(ra))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
filter1_ = create_filter(self.request, cls, geom_attr)
ra = cascaded_union(collect_ra)
filter2_ = ga_func.ST_Contains(
from_shape(ra, use_srid),
getattr(cls, geom_attr)
)
filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
return proto.read(self.request, filter=filter_)
def _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = DBSession.query(RestrictionArea.area,
functions.srid(RestrictionArea.area))
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(wkb.loads(str(ra.geom_wkb)))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
ra = cascaded_union(collect_ra)
filter_ = and_(
create_filter(self.request, cls, geom_attr),
functions.gcontains(func.st_geomfromtext(ra.wkt, use_srid),
getattr(cls, geom_attr)))
return proto.read(self.request, filter=filter_)
def _proto_read(layer, request):
""" Read features for the layer based on the request. """
if layer.public:
return _get_protocol_for_layer(layer).read(request)
if request.user is None:
return FeatureCollection([])
user = request.user
proto = _get_protocol_for_layer(layer)
cls = proto.mapped_class
geom_attr = proto.geom_attr
ra = DBSession.query(RestrictionArea.area.collect)
ra = ra.join(RestrictionArea.roles)
ra = ra.join(RestrictionArea.layers)
ra = ra.filter(RestrictionArea.area.area > 0)
ra = ra.filter(Role.id == user.role.id)
ra = ra.filter(Layer.id == layer.id).scalar()
ra = DBSpatialElement(ra)
filter_ = and_(create_filter(request, cls, geom_attr),
ra.gcontains(getattr(cls, geom_attr)))
return proto.read(request, filter=filter_)
def _proto_read(layer, request):
""" Read features for the layer based on the request. """
if layer.public:
return _get_protocol_for_layer(layer).read(request)
if request.user is None:
return FeatureCollection([])
user = request.user
proto = _get_protocol_for_layer(layer)
cls = proto.mapped_class
geom_attr = proto.geom_attr
ra = DBSession.query(RestrictionArea.area.collect)
ra = ra.join(RestrictionArea.roles)
ra = ra.join(RestrictionArea.layers)
ra = ra.filter(RestrictionArea.area.area > 0)
ra = ra.filter(Role.id == user.role.id)
ra = ra.filter(Layer.id == layer.id).scalar()
ra = DBSpatialElement(ra)
filter_ = and_(create_filter(request, cls, geom_attr),
ra.gcontains(getattr(cls, geom_attr)))
return proto.read(request, filter=filter_)
def _proto_read(self, layer: "main.Layer") -> FeatureCollection:
""" Read features for the layer based on the self.request. """
from c2cgeoportal_commons.models.main import ( # pylint: disable=import-outside-toplevel
Layer, RestrictionArea, Role,
)
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = models.DBSession.query(RestrictionArea.area,
RestrictionArea.area.ST_SRID())
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id.in_(get_roles_id(self.request)))
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
use_srid = srid
collect_ra.append(to_shape(ra))
if not collect_ra:
raise HTTPForbidden()
filter1_ = create_filter(self.request, cls, geom_attr)
ra = cascaded_union(collect_ra)
filter2_ = ga_func.ST_Contains(from_shape(ra, use_srid),
getattr(cls, geom_attr))
filter_ = filter2_ if filter1_ is None else and_(filter1_, filter2_)
feature = proto.read(self.request, filter=filter_)
if isinstance(feature, HTTPException):
raise feature # pylint: disable=raising-non-exception
return feature
def _proto_read(self, layer):
""" Read features for the layer based on the self.request. """
proto = self._get_protocol_for_layer(layer)
if layer.public:
return proto.read(self.request)
user = self.request.user
if user is None:
raise HTTPForbidden()
cls = proto.mapped_class
geom_attr = proto.geom_attr
ras = DBSession.query(RestrictionArea.area, functions.srid(RestrictionArea.area))
ras = ras.join(RestrictionArea.roles)
ras = ras.join(RestrictionArea.layers)
ras = ras.filter(Role.id == user.role.id)
ras = ras.filter(Layer.id == layer.id)
collect_ra = []
use_srid = -1
for ra, srid in ras.all():
if ra is None:
return proto.read(self.request)
else:
use_srid = srid
collect_ra.append(wkb.loads(str(ra.geom_wkb)))
if len(collect_ra) == 0: # pragma: no cover
raise HTTPForbidden()
ra = cascaded_union(collect_ra)
filter_ = and_(
create_filter(self.request, cls, geom_attr),
functions.gcontains(
func.st_geomfromtext(ra.wkt, use_srid),
getattr(cls, geom_attr)
)
)
return proto.read(self.request, filter=filter_)
