@property
def geomtransform(self):
geom = self.topo_object.geom
return geom.transform(settings.API_SRID, clone=True)
@property
def lat_value(self):
return self.geomtransform.x
@property
def lng_value(self):
return self.geomtransform.y
Path.add_property('signages', lambda self: Signage.path_signages(self),
_("Signages"))
Topology.add_property('signages', Signage.topology_signages, _("Signages"))
Topology.add_property('published_signages',
lambda self: Signage.published_topology_signages(self),
_("Published Signages"))
class Direction(models.Model):
label = models.CharField(db_column="etiquette", max_length=128)
class Meta:
db_table = 's_b_direction'
verbose_name = _("Direction")
verbose_name_plural = _("Directions")
def __str__(self):
def save(self, *args, **kwargs):
if self.pk is not None and kwargs.get('update_fields', None) is None:
field_names = set()
for field in self._meta.concrete_fields:
if not field.primary_key and not hasattr(field, 'through'):
field_names.add(field.attname)
old_trek = Trek.objects.get(pk=self.pk)
if self.geom is not None and old_trek.geom.equals_exact(self.geom, tolerance=0.00001):
field_names.remove('geom')
if self.geom_3d is not None and old_trek.geom_3d.equals_exact(self.geom_3d, tolerance=0.00001):
field_names.remove('geom_3d')
return super(Trek, self).save(update_fields=field_names, *args, **kwargs)
super(Trek, self).save(*args, **kwargs)
Path.add_property('treks', Trek.path_treks, _(u"Treks"))
Topology.add_property('treks', Trek.topology_treks, _(u"Treks"))
if settings.HIDE_PUBLISHED_TREKS_IN_TOPOLOGIES:
Topology.add_property('published_treks', lambda self: [], _(u"Published treks"))
else:
Topology.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _(u"Published treks"))
Intervention.add_property('treks', lambda self: self.topology.treks if self.topology else [], _(u"Treks"))
Project.add_property('treks', lambda self: self.edges_by_attr('treks'), _(u"Treks"))
tourism_models.TouristicContent.add_property('treks', lambda self: intersecting(Trek, self), _(u"Treks"))
tourism_models.TouristicContent.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _(u"Published treks"))
tourism_models.TouristicEvent.add_property('treks', lambda self: intersecting(Trek, self), _(u"Treks"))
tourism_models.TouristicEvent.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _(u"Published treks"))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
self.physical_type
)
@property
def physical_type_csv_display(self):
return unicode(self.physical_type)
@classmethod
def path_physicals(cls, path):
return cls.objects.select_related('physical_type').filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_physicals(cls, topology):
return cls.overlapping(topology).select_related('physical_type')
Path.add_property('physical_edges', PhysicalEdge.path_physicals)
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals)
Intervention.add_property('physical_edges', lambda self: self.topology.physical_edges if self.topology else [])
Project.add_property('physical_edges', lambda self: self.edges_by_attr('physical_edges'))
class LandType(StructureRelated):
name = models.CharField(max_length=128, db_column='foncier', verbose_name=_(u"Name"))
right_of_way = models.BooleanField(db_column='droit_de_passage', verbose_name=_(u"Right of way"))
class Meta:
db_table = 'f_b_foncier'
verbose_name = _(u"Land type")
verbose_name_plural = _(u"Land types")
ordering = ['name']
return all_years
class Infrastructure(MapEntityMixin, BaseInfrastructure):
""" An infrastructure in the park, which is not of type SIGNAGE """
type = models.ForeignKey(InfrastructureType, db_column='type', verbose_name=_("Type"))
objects = BaseInfrastructure.get_manager_cls(InfrastructureGISManager)()
class Meta:
db_table = 'a_t_infrastructure'
verbose_name = _(u"Infrastructure")
verbose_name_plural = _(u"Infrastructures")
@classmethod
def path_infrastructures(cls, path):
return cls.objects.existing().filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_infrastructures(cls, topology):
return cls.overlapping(topology)
@classmethod
def published_topology_infrastructure(cls, topology):
return cls.topology_infrastructures(topology).filter(published=True)
Path.add_property('infrastructures', lambda self: Infrastructure.path_infrastructures(self), _(u"Infrastructures"))
Topology.add_property('infrastructures', lambda self: Infrastructure.topology_infrastructures(self), _(u"Infrastructures"))
Topology.add_property('published_infrastructures', Infrastructure.published_topology_infrastructure,
_(u"Published Infrastructures"))
class Meta:
proxy = True
verbose_name = _(u"Infrastructure")
verbose_name_plural = _(u"Infrastructures")
@classmethod
def path_infrastructures(cls, path):
return cls.objects.existing().filter(aggregations__path=path).distinct("pk")
@classmethod
def topology_infrastructures(cls, topology):
return cls.overlapping(topology)
Path.add_property("infrastructures", lambda self: Infrastructure.path_infrastructures(self), _(u"Infrastructures"))
Topology.add_property(
"infrastructures", lambda self: Infrastructure.topology_infrastructures(self), _(u"Infrastructures")
)
class SignageGISManager(gismodels.GeoManager):
""" Overide default typology mixin manager, and filter by type. """
def get_queryset(self):
return super(SignageGISManager, self).get_queryset().filter(type__type=INFRASTRUCTURE_TYPES.SIGNAGE)
class SignageStructureManager(StructureRelatedManager):
""" Overide default structure related manager, and filter by type. """
def __unicode__(self):
return u"%s (%s)" % (self.name, self.date)
@classmethod
def path_interventions(cls, path):
return cls.objects.existing().filter(topology__aggregations__path=path)
@classmethod
def topology_interventions(cls, topology):
topos = Topology.overlapping(topology).values_list('pk', flat=True)
return cls.objects.existing().filter(topology__in=topos).distinct('pk')
Path.add_property('interventions',
lambda self: Intervention.path_interventions(self),
_(u"Interventions"))
Topology.add_property('interventions',
lambda self: Intervention.topology_interventions(self),
_(u"Interventions"))
class InterventionStatus(StructureOrNoneRelated):
status = models.CharField(verbose_name=_(u"Status"),
max_length=128,
db_column='status')
class Meta:
db_table = 'm_b_suivi'
verbose_name = _(u"Intervention's status")
return unicode(self.name)
def __unicode__(self):
return u"%s (%s)" % (self.name, self.date)
@classmethod
def path_interventions(cls, path):
return cls.objects.existing().filter(topology__aggregations__path=path)
@classmethod
def topology_interventions(cls, topology):
topos = Topology.overlapping(topology).values_list('pk', flat=True)
return cls.objects.existing().filter(topology__in=topos).distinct('pk')
Path.add_property('interventions', lambda self: Intervention.path_interventions(self), _(u"Interventions"))
Topology.add_property('interventions', lambda self: Intervention.topology_interventions(self), _(u"Interventions"))
class InterventionStatus(StructureOrNoneRelated):
status = models.CharField(verbose_name=_(u"Status"), max_length=128, db_column='status')
class Meta:
db_table = 'm_b_suivi'
verbose_name = _(u"Intervention's status")
verbose_name_plural = _(u"Intervention's statuses")
ordering = ['id']
def __unicode__(self):
if self.structure:
@classmethod
def path_area_edges(cls, path):
return cls.objects.existing()\
.select_related('restricted_area')\
.select_related('restricted_area__area_type')\
.filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_area_edges(cls, topology):
return cls.overlapping(topology)\
.select_related('restricted_area')\
.select_related('restricted_area__area_type')
if settings.TREKKING_TOPOLOGY_ENABLED:
Path.add_property('area_edges', RestrictedAreaEdge.path_area_edges)
Path.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)))
Topology.add_property('area_edges', RestrictedAreaEdge.topology_area_edges)
Topology.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)))
Intervention.add_property('area_edges', lambda self: self.topology.area_edges if self.topology else [])
Intervention.add_property('areas', lambda self: self.topology.areas if self.topology else [])
Project.add_property('area_edges', lambda self: self.edges_by_attr('area_edges'))
Project.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)))
else:
Topology.add_property('areas', lambda self: intersecting(RestrictedArea, self))
TouristicContent.add_property('areas', lambda self: intersecting(RestrictedArea, self))
TouristicEvent.add_property('areas', lambda self: intersecting(RestrictedArea, self))
class City(models.Model):
aggregations__path=path).distinct('pk')
else:
area = path.geom.buffer(
settings.TREK_INFRASTRUCTURE_INTERSECTION_MARGIN)
return cls.objects.existing().filter(geom__intersects=area)
@classmethod
def topology_infrastructures(cls, topology):
if settings.TREKKING_TOPOLOGY_ENABLED:
qs = cls.overlapping(topology)
else:
area = topology.geom.buffer(
settings.TREK_INFRASTRUCTURE_INTERSECTION_MARGIN)
qs = cls.objects.existing().filter(geom__intersects=area)
return qs
@classmethod
def published_topology_infrastructure(cls, topology):
return cls.topology_infrastructures(topology).filter(published=True)
Path.add_property('infrastructures',
lambda self: Infrastructure.path_infrastructures(self),
_("Infrastructures"))
Topology.add_property('infrastructures',
Infrastructure.topology_infrastructures,
_("Infrastructures"))
Topology.add_property('published_infrastructures',
Infrastructure.published_topology_infrastructure,
_("Published Infrastructures"))
@classmethod
def path_area_edges(cls, path):
return cls.objects.existing()\
.select_related('restricted_area')\
.select_related('restricted_area__area_type')\
.filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_area_edges(cls, topology):
return cls.overlapping(topology)\
.select_related('restricted_area')\
.select_related('restricted_area__area_type')
if settings.TREKKING_TOPOLOGY_ENABLED:
Path.add_property('area_edges', RestrictedAreaEdge.path_area_edges, _("Restricted area edges"))
Path.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)),
_("Restricted areas"))
Topology.add_property('area_edges', RestrictedAreaEdge.topology_area_edges, _("Restricted area edges"))
Topology.add_property('areas', lambda self: uniquify(
intersecting(RestrictedArea, self)) if self.ispoint() else uniquify(
map(attrgetter('restricted_area'), self.area_edges)), _("Restricted areas"))
Intervention.add_property('area_edges', lambda self: self.topology.area_edges if self.topology else [],
_("Restricted area edges"))
Intervention.add_property('areas', lambda self: self.topology.areas if self.topology else [],
_("Restricted areas"))
Project.add_property('area_edges', lambda self: self.edges_by_attr('area_edges'), _("Restricted area edges"))
Project.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)),
_("Restricted areas"))
else:
Topology.add_property('areas', lambda self: uniquify(intersecting(RestrictedArea, self, distance=0)),
in_structure = InfrastructureStructureManager()
class Meta:
proxy = True
verbose_name = _(u"Infrastructure")
verbose_name_plural = _(u"Infrastructures")
@classmethod
def path_infrastructures(cls, path):
return cls.objects.filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_infrastructures(cls, topology):
return cls.objects.filter(aggregations__path__in=topology.paths.all()).distinct('pk')
Path.add_property('infrastructures', lambda self: Infrastructure.path_infrastructures(self))
Topology.add_property('infrastructures', lambda self: Infrastructure.topology_infrastructures(self))
class SignageGISManager(gismodels.GeoManager):
""" Overide default typology mixin manager, and filter by type. """
def get_query_set(self):
return super(SignageGISManager, self).get_query_set().filter(type__type=INFRASTRUCTURE_TYPES.SIGNAGE)
class SignageStructureManager(StructureRelatedManager):
""" Overide default structure related manager, and filter by type. """
def get_query_set(self):
return super(SignageStructureManager, self).get_query_set().filter(type__type=INFRASTRUCTURE_TYPES.SIGNAGE)
@classmethod
def path_area_edges(cls, path):
return cls.objects.existing()\
.select_related('restricted_area')\
.select_related('restricted_area__area_type')\
.filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_area_edges(cls, topology):
return cls.overlapping(topology)\
.select_related('restricted_area')\
.select_related('restricted_area__area_type')
if settings.TREKKING_TOPOLOGY_ENABLED:
Path.add_property('area_edges', RestrictedAreaEdge.path_area_edges,
_("Restricted area edges"))
Path.add_property(
'areas', lambda self: uniquify(
map(attrgetter('restricted_area'), self.area_edges)),
_("Restricted areas"))
Path.add_property(
'published_areas',
lambda self: [area for area in self.areas if area.published],
_("Published areas"))
Topology.add_property('area_edges', RestrictedAreaEdge.topology_area_edges,
_("Restricted area edges"))
Topology.add_property(
'areas', lambda self: uniquify(intersecting(RestrictedArea, self))
if self.ispoint() else uniquify(
map(attrgetter('restricted_area'), self.area_edges)),
_("Restricted areas"))
def is_publishable(self):
return self.is_complete() and self.has_geom_valid()
def __unicode__(self):
return u"%s (%s - %s)" % (self.name, self.departure, self.arrival)
@classmethod
def path_treks(cls, path):
return cls.objects.existing().filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_treks(cls, topology):
return cls.objects.existing().filter(aggregations__path__in=topology.paths.all()).distinct('pk')
Path.add_property('treks', lambda self: Trek.path_treks(self))
Topology.add_property('treks', lambda self: Trek.topology_treks(self))
Intervention.add_property('treks', lambda self: self.topology.treks if self.topology else [])
Project.add_property('treks', lambda self: self.edges_by_attr('treks'))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
def get_query_set(self):
# Select treks foreign keys by default
qs = super(TrekRelationshipManager, self).get_query_set().select_related('trek_a', 'trek_b')
# Exclude deleted treks
return qs.exclude(trek_a__deleted=True).exclude(trek_b__deleted=True)
return trekking_tags.duration(self.duration)
def __unicode__(self):
return u"%s (%s - %s)" % (self.name, self.departure, self.arrival)
@classmethod
def path_treks(cls, path):
return cls.objects.existing().filter(
aggregations__path=path).distinct('pk')
@classmethod
def topology_treks(cls, topology):
return cls.overlapping(topology)
Path.add_property('treks', Trek.path_treks)
Topology.add_property('treks', Trek.topology_treks)
Intervention.add_property(
'treks', lambda self: self.topology.treks if self.topology else [])
Project.add_property('treks', lambda self: self.edges_by_attr('treks'))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
def get_query_set(self):
# Select treks foreign keys by default
qs = super(TrekRelationshipManager,
self).get_query_set().select_related('trek_a', 'trek_b')
# Exclude deleted treks
return qs.exclude(trek_a__deleted=True).exclude(trek_b__deleted=True)
def duration_pretty(self):
return trekking_tags.duration(self.duration)
def __unicode__(self):
return u"%s (%s - %s)" % (self.name, self.departure, self.arrival)
@classmethod
def path_treks(cls, path):
return cls.objects.existing().filter(aggregations__path=path).distinct("pk")
@classmethod
def topology_treks(cls, topology):
return cls.overlapping(topology)
Path.add_property("treks", Trek.path_treks)
Topology.add_property("treks", Trek.topology_treks)
Intervention.add_property("treks", lambda self: self.topology.treks if self.topology else [])
Project.add_property("treks", lambda self: self.edges_by_attr("treks"))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
def get_query_set(self):
# Select treks foreign keys by default
qs = super(TrekRelationshipManager, self).get_query_set().select_related("trek_a", "trek_b")
# Exclude deleted treks
return qs.exclude(trek_a__deleted=True).exclude(trek_b__deleted=True)
@property
def geomtransform(self):
geom = self.topo_object.geom
return geom.transform(settings.API_SRID, clone=True)
@property
def lat_value(self):
return self.geomtransform.x
@property
def lng_value(self):
return self.geomtransform.y
Path.add_property('signages', lambda self: Signage.path_signages(self), _(u"Signages"))
Topology.add_property('signages', lambda self: Signage.topology_signages(self), _(u"Signages"))
Topology.add_property('published_signages', lambda self: Signage.published_topology_signages(self),
_(u"Published Signages"))
class Direction(models.Model):
label = models.CharField(db_column="etiquette", max_length=128)
class Meta:
db_table = 's_b_direction'
verbose_name = _(u"Direction")
verbose_name_plural = _(u"Directions")
def __unicode__(self):
return self.label
def path_treks(cls, path):
treks = cls.objects.existing().filter(aggregations__path=path)
# The following part prevents conflict with default trek ordering
# ProgrammingError: SELECT DISTINCT ON expressions must match initial ORDER BY expressions
return treks.order_by('topo_object').distinct('topo_object')
@classmethod
def topology_treks(cls, topology):
if settings.TREKKING_TOPOLOGY_ENABLED:
qs = cls.overlapping(topology)
else:
area = topology.geom.buffer(settings.TREK_POI_INTERSECTION_MARGIN)
qs = cls.objects.filter(geom__intersects=area)
return qs
Path.add_property('treks', Trek.path_treks)
Topology.add_property('treks', Trek.topology_treks)
Intervention.add_property('treks', lambda self: self.topology.treks if self.topology else [])
Project.add_property('treks', lambda self: self.edges_by_attr('treks'))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
def get_queryset(self):
# Select treks foreign keys by default
qs = super(TrekRelationshipManager, self).get_queryset().select_related('trek_a', 'trek_b')
# Exclude deleted treks
return qs.exclude(trek_a__deleted=True).exclude(trek_b__deleted=True)
def physical_type_csv_display(self):
return unicode(self.physical_type)
@property
def display(self):
return u'<a data-pk="%s" href="%s" >%s</a>' % (self.pk, self.get_detail_url(), self.physical_type)
@classmethod
def path_physicals(cls, path):
return cls.objects.select_related('physical_type').filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_physicals(cls, topology):
return cls.objects.select_related('physical_type').filter(aggregations__path__in=topology.paths.all()).distinct('pk')
Path.add_property('physical_edges', PhysicalEdge.path_physicals)
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals)
Intervention.add_property('physical_edges', lambda self: self.topology.physical_edges if self.topology else [])
Project.add_property('physical_edges', lambda self: self.edges_by_attr('physical_edges'))
class LandType(StructureRelated):
name = models.CharField(max_length=128, db_column='foncier', verbose_name=_(u"Name"))
right_of_way = models.BooleanField(db_column='droit_de_passage', verbose_name=_(u"Right of way"))
class Meta:
db_table = 'f_b_foncier'
verbose_name = _(u"Land type")
verbose_name_plural = _(u"Land types")
ordering = ['name']
return [o for o, _o in self.ORIENTATION_CHOICES
if o in orientation] # Sorting
@property
def super_wind(self):
"Return wind of itself and its descendants"
wind = set(
sum(
self.get_descendants(include_self=True).values_list('wind',
flat=True),
[]))
return [o for o, _o in self.ORIENTATION_CHOICES
if o in wind] # Sorting
Path.add_property('sites', lambda self: intersecting(Site, self), _("Sites"))
Topology.add_property('sites', lambda self: intersecting(Site, self),
_("Sites"))
TouristicContent.add_property('sites', lambda self: intersecting(Site, self),
_("Sites"))
TouristicEvent.add_property('sites', lambda self: intersecting(Site, self),
_("Sites"))
Site.add_property('sites', lambda self: intersecting(Site, self), _("Sites"))
Site.add_property('treks', lambda self: intersecting(Trek, self), _("Treks"))
Site.add_property('pois', lambda self: intersecting(POI, self), _("POIs"))
Site.add_property('trails', lambda self: intersecting(Trail, self),
_("Trails"))
Site.add_property('infrastructures',
lambda self: intersecting(Infrastructure, self),
_("Infrastructures"))
settings.LEAFLET_CONFIG['TILES'][0][0],
]
if settings.SHOW_SENSITIVE_AREAS_ON_MAP_SCREENSHOT:
maplayers.append(ugettext(u"Sensitive area"))
if settings.SHOW_POIS_ON_MAP_SCREENSHOT:
maplayers.append(ugettext(u"POIs"))
if settings.SHOW_SERVICES_ON_MAP_SCREENSHOT:
maplayers.append(ugettext(u"Services"))
if settings.SHOW_SIGNAGES_ON_MAP_SCREENSHOT:
maplayers.append(ugettext(u"Signages"))
if settings.SHOW_INFRASTRUCTURES_ON_MAP_SCREENSHOT:
maplayers.append(ugettext(u"Infrastructures"))
return {"maplayers": maplayers}
Path.add_property('treks', Trek.path_treks, _(u"Treks"))
Topology.add_property('treks', Trek.topology_treks, _(u"Treks"))
if settings.HIDE_PUBLISHED_TREKS_IN_TOPOLOGIES:
Topology.add_property('published_treks', lambda self: [], _(u"Published treks"))
else:
Topology.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _(u"Published treks"))
Intervention.add_property('treks', lambda self: self.topology.treks if self.topology else [], _(u"Treks"))
Project.add_property('treks', lambda self: self.edges_by_attr('treks'), _(u"Treks"))
tourism_models.TouristicContent.add_property('treks', lambda self: intersecting(Trek, self), _(u"Treks"))
tourism_models.TouristicContent.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _(u"Published treks"))
tourism_models.TouristicEvent.add_property('treks', lambda self: intersecting(Trek, self), _(u"Treks"))
tourism_models.TouristicEvent.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _(u"Published treks"))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
self.physical_type
)
@property
def physical_type_csv_display(self):
return unicode(self.physical_type)
@classmethod
def path_physicals(cls, path):
return cls.objects.existing().select_related('physical_type').filter(aggregations__path=path).distinct('pk')
@classmethod
def topology_physicals(cls, topology):
return cls.overlapping(topology).select_related('physical_type')
Path.add_property('physical_edges', PhysicalEdge.path_physicals, _(u"Physical edges"))
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals, _(u"Physical edges"))
Intervention.add_property('physical_edges', lambda self: self.topology.physical_edges if self.topology else [], _(u"Physical edges"))
Project.add_property('physical_edges', lambda self: self.edges_by_attr('physical_edges'), _(u"Physical edges"))
class LandType(StructureRelated):
name = models.CharField(max_length=128, db_column='foncier', verbose_name=_(u"Name"))
right_of_way = models.BooleanField(db_column='droit_de_passage', verbose_name=_(u"Right of way"))
class Meta:
db_table = 'f_b_foncier'
verbose_name = _(u"Land type")
verbose_name_plural = _(u"Land types")
ordering = ['name']
@property
def display(self):
return u'<a data-pk="%s" href="%s" >%s</a>' % (
self.pk, self.get_detail_url(), self.physical_type)
@classmethod
def path_physicals(cls, path):
return cls.objects.select_related('physical_type').filter(
aggregations__path=path).distinct('pk')
@classmethod
def topology_physicals(cls, topology):
return cls.overlapping(topology).select_related('physical_type')
Path.add_property('physical_edges', PhysicalEdge.path_physicals)
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals)
Intervention.add_property(
'physical_edges', lambda self: self.topology.physical_edges
if self.topology else [])
Project.add_property('physical_edges',
lambda self: self.edges_by_attr('physical_edges'))
class LandType(StructureRelated):
name = models.CharField(max_length=128,
db_column='foncier',
verbose_name=_(u"Name"))
right_of_way = models.BooleanField(db_column='droit_de_passage',
verbose_name=_(u"Right of way"))
@classmethod
def path_infrastructures(cls, path):
return cls.objects.existing().filter(
aggregations__path=path).distinct('pk')
@classmethod
def topology_infrastructures(cls, topology):
return cls.overlapping(topology)
@classmethod
def published_topology_infrastructure(cls, topology):
return cls.topology_infrastructures(topology).filter(published=True)
Path.add_property('infrastructures',
lambda self: Infrastructure.path_infrastructures(self),
_(u"Infrastructures"))
Topology.add_property(
'infrastructures',
lambda self: Infrastructure.topology_infrastructures(self),
_(u"Infrastructures"))
Topology.add_property('published_infrastructures',
Infrastructure.published_topology_infrastructure,
_(u"Published Infrastructures"))
class SignageGISManager(gismodels.GeoManager):
""" Overide default typology mixin manager, and filter by type. """
def get_queryset(self):
return super(SignageGISManager, self).get_queryset().filter(
type__type=INFRASTRUCTURE_TYPES.SIGNAGE)
@property
def physical_type_csv_display(self):
return unicode(self.physical_type)
@classmethod
def path_physicals(cls, path):
return cls.objects.existing().select_related('physical_type').filter(
aggregations__path=path).distinct('pk')
@classmethod
def topology_physicals(cls, topology):
return cls.overlapping(topology).select_related('physical_type')
Path.add_property('physical_edges', PhysicalEdge.path_physicals,
_(u"Physical edges"))
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals,
_(u"Physical edges"))
Intervention.add_property(
'physical_edges', lambda self: self.topology.physical_edges
if self.topology else [], _(u"Physical edges"))
Project.add_property('physical_edges',
lambda self: self.edges_by_attr('physical_edges'),
_(u"Physical edges"))
class LandType(StructureOrNoneRelated):
name = models.CharField(max_length=128,
db_column='foncier',
verbose_name=_(u"Name"))
right_of_way = models.BooleanField(default=False,
@property
def physical_type_csv_display(self):
return unicode(self.physical_type)
@classmethod
def path_physicals(cls, path):
return cls.objects.select_related('physical_type').filter(
aggregations__path=path).distinct('pk')
@classmethod
def topology_physicals(cls, topology):
return cls.overlapping(topology).select_related('physical_type')
Path.add_property('physical_edges', PhysicalEdge.path_physicals)
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals)
Intervention.add_property(
'physical_edges', lambda self: self.topology.physical_edges
if self.topology else [])
Project.add_property('physical_edges',
lambda self: self.edges_by_attr('physical_edges'))
class LandType(StructureRelated):
name = models.CharField(max_length=128,
db_column='foncier',
verbose_name=_(u"Name"))
right_of_way = models.BooleanField(db_column='droit_de_passage',
verbose_name=_(u"Right of way"))
