def test_creation_form_on_signage(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
signa = SignageFactory.create()
else:
signa = SignageFactory.create(geom='SRID=2154;POINT (700000 6600000)')
signage = "%s" % signa
response = self.client.get('%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(),
signa.pk,
ContentType.objects.get_for_model(Signage).pk
))
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['target_id'], str(signa.pk))
# Should be able to save form successfully
data = self.get_good_data()
data['target_id'] = signa.pk
response = self.client.post('%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(),
signa.pk,
ContentType.objects.get_for_model(Signage).pk
),
data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_infrastructure_with_errors(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
response = self.client.get(
'%s?target_id=%s&target_type=%s' %
(Intervention.get_add_url(), infra.pk,
ContentType.objects.get_for_model(Infrastructure).pk))
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
data = self.get_good_data()
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(
'%s?target_id=%s&target_type=%s' %
(Intervention.get_add_url(), infra.pk,
ContentType.objects.get_for_model(Infrastructure).pk), data)
self.assertEqual(response.status_code, 200)
def test_creation_form_on_signage(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
response = self.client.get(Intervention.get_add_url() + '?signage=%s' % signa.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['signage'], signa)
# Should be able to save form successfully
data = self.get_good_data()
data['signage'] = signa.pk
response = self.client.post(Intervention.get_add_url() + '?signage=%s' % signa.pk, data)
self.assertEqual(response.status_code, 302)
def test_update_form_on_infrastructure(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
intervention = InterventionFactory.create(target=infra)
response = self.client.get(intervention.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# Should be able to save form successfully
form = response.context['form']
data = form.initial
data['disorders'] = data['disorders'][0].pk
data['project'] = ''
data.update(
**{
'manday_set-TOTAL_FORMS': '0',
'manday_set-INITIAL_FORMS': '0',
'manday_set-MAX_NUM_FORMS': '',
})
# Form URL is modified in form init
formurl = '%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(
), infra.pk, ContentType.objects.get_for_model(Infrastructure).pk)
response = self.client.post(formurl, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
# Should be able to save form successfully
data = self.get_good_data()
data['infrastructure'] = infra.pk
response = self.client.post(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
# Should be able to save form successfully
data = self.get_good_data()
data['infrastructure'] = infra.pk
response = self.client.post(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_infrastructure_with_errors(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
data = self.get_good_data()
data['infrastructure'] = infra.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 200)
def test_creation_form_on_infrastructure_with_errors(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
data = self.get_good_data()
data['infrastructure'] = infra.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 200)
def test_structurerelated_not_loggedin(self):
# Test that it does not fail on update if not logged in
self.client.logout()
response = self.client.get(Intervention.get_add_url())
self.assertEqual(response.status_code, 302)
i = InterventionFactory.create()
response = self.client.get(i.get_update_url())
self.assertEqual(response.status_code, 302)
def test_structurerelated_not_loggedin(self):
# Test that it does not fail on update if not logged in
self.client.logout()
response = self.client.get(Intervention.get_add_url())
self.assertEqual(response.status_code, 302)
i = InterventionFactory.create()
response = self.client.get(i.get_update_url())
self.assertEqual(response.status_code, 302)
def test_creation_form_on_signage(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
response = self.client.get(Intervention.get_add_url() +
'?signage=%s' % signa.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['signage'], signa)
# Should be able to save form successfully
data = self.get_good_data()
data['signage'] = signa.pk
response = self.client.post(
Intervention.get_add_url() + '?signage=%s' % signa.pk, data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_infrastructure(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(geom='SRID=2154;POINT (700000 6600000)')
response = self.client.get('%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(),
infra.pk,
ContentType.objects.get_for_model(Infrastructure).pk))
self.assertEqual(response.status_code, 200)
# Should be able to save form successfully
data = self.get_good_data()
response = self.client.post('%s?target_id=%s&target_type=%s' % (Intervention.get_add_url(),
infra.pk,
ContentType.objects.get_for_model(Infrastructure).pk),
data)
self.assertEqual(response.status_code, 302)
def test_creation_form_on_signage_with_errors(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
response = self.client.get(Intervention.get_add_url() + '?signage=%s' % signa.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['signage'], signa)
data = self.get_good_data()
data['signage'] = signa.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(Intervention.get_add_url() + '?signage=%s' % signa.pk, data)
self.assertEqual(response.status_code, 200)
def test_creation_form_on_signage_with_errors(self):
self.login()
signa = SignageFactory.create()
signage = u"%s" % signa
response = self.client.get(Intervention.get_add_url() +
'?signage=%s' % signa.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, signage)
form = response.context['form']
self.assertEqual(form.initial['signage'], signa)
data = self.get_good_data()
data['signage'] = signa.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(
Intervention.get_add_url() + '?signage=%s' % signa.pk, data)
self.assertEqual(response.status_code, 200)
def test_creation_form_on_infrastructure(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
response = self.client.get(Intervention.get_add_url() +
'?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
# Should be able to save form successfully
data = self.get_good_data()
data['infrastructure'] = infra.pk
response = self.client.post(
Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 302)
def test_form_default_stake(self):
self.login()
good_data = self.get_good_data()
good_data['stake'] = ''
good_data['topology'] = """
{"offset":0,"positions":{"0":[0.8298653170816073,1],"2":[0,0.04593024777973237]},"paths":[%s,%s,%s]}
""" % (PathFactory.create().pk, PathFactory.create().pk, PathFactory.create().pk)
response = self.client.post(Intervention.get_add_url(), good_data)
self.assertEqual(response.status_code, 302)
response = self.client.get(response._headers['location'][1])
self.assertTrue('object' in response.context)
intervention = response.context['object']
self.assertFalse(intervention.stake is None)
def test_form_default_stake(self):
self.login()
good_data = self.get_good_data()
good_data['stake'] = ''
good_data['topology'] = """
{"offset":0,"positions":{"0":[0.8298653170816073,1],"2":[0,0.04593024777973237]},"paths":[%s,%s,%s]}
""" % (PathFactory.create().pk, PathFactory.create().pk, PathFactory.create().pk)
response = self.client.post(Intervention.get_add_url(), good_data)
self.assertEqual(response.status_code, 302)
response = self.client.get(response._headers['location'][1])
self.assertTrue('object' in response.context)
intervention = response.context['object']
self.assertFalse(intervention.stake is None)
def test_creation_form_line(self):
path = PathFactory.create(geom=LineString(Point(700000, 6600000), Point(700300, 6600300), srid=settings.SRID))
self.super_user = SuperUserFactory.create(username='******', password='******')
self.client.login(username='******', password='******')
data = self.get_good_data()
data['structure'] = StructureFactory.create().pk
data['topology'] = '{"paths": [%s], "positions":{"0":[0,1]}}' % path.pk,
response = self.client.post('%s' % (Intervention.get_add_url()),
data)
self.assertEqual(PathAggregation.objects.count(), 1)
self.assertEqual(response.status_code, 302)
self.assertEqual(Intervention.objects.first().geom, path.geom)
self.assertEqual(Intervention.objects.first().target.kind, 'INTERVENTION')
def test_form_on_infrastructure(self):
self.login()
infra = InfrastructureFactory.create()
infrastr = u"%s" % infra
# For creation
response = self.client.get(Intervention.get_add_url() + '?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
# For edition
intervention = InterventionFactory.create()
intervention.set_infrastructure(infra)
response = self.client.get(infra.get_update_url())
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
def test_creation_form_on_infrastructure_with_errors(self):
self.login()
if settings.TREKKING_TOPOLOGY_ENABLED:
infra = InfrastructureFactory.create()
else:
infra = InfrastructureFactory.create(
geom='SRID=2154;POINT (700000 6600000)')
infrastr = "%s" % infra
response = self.client.get(Intervention.get_add_url() +
'?infrastructure=%s' % infra.pk)
self.assertEqual(response.status_code, 200)
self.assertContains(response, infrastr)
form = response.context['form']
self.assertEqual(form.initial['infrastructure'], infra)
data = self.get_good_data()
data['infrastructure'] = infra.pk
# If form invalid, it should not fail
data.pop('status')
response = self.client.post(
Intervention.get_add_url() + '?infrastructure=%s' % infra.pk, data)
self.assertEqual(response.status_code, 200)
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)
class TrekRelationship(models.Model):
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
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)
@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, _(u"Restricted area edges"))
Path.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)),
_(u"Restricted areas"))
Topology.add_property('area_edges', RestrictedAreaEdge.topology_area_edges, _(u"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)), _(u"Restricted areas"))
Intervention.add_property('area_edges', lambda self: self.topology.area_edges if self.topology else [],
_(u"Restricted area edges"))
Intervention.add_property('areas', lambda self: self.topology.areas if self.topology else [],
_(u"Restricted areas"))
Project.add_property('area_edges', lambda self: self.edges_by_attr('area_edges'), _(u"Restricted area edges"))
Project.add_property('areas', lambda self: uniquify(map(attrgetter('restricted_area'), self.area_edges)),
_(u"Restricted areas"))
else:
Topology.add_property('areas', lambda self: uniquify(intersecting(RestrictedArea, self, distance=0)),
_(u"Restricted areas"))
TouristicContent.add_property('areas', lambda self: intersecting(RestrictedArea, self, distance=0),
_(u"Restricted areas"))
TouristicEvent.add_property('areas', lambda self: intersecting(RestrictedArea, self, distance=0),
_(u"Restricted areas"))
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)
class TrekRelationship(models.Model):
"""
@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)),
_("Restricted areas"))
Project.add_property('areas', lambda self: uniquify(intersecting(RestrictedArea, self, distance=0)),
_("Restricted areas"))
Intervention.add_property('areas', lambda self: uniquify(intersecting(RestrictedArea, self, distance=0)),
_("Restricted areas"))
TouristicContent.add_property('areas', lambda self: intersecting(RestrictedArea, self, distance=0),
_("Restricted areas"))
if settings.SHOW_SERVICES_ON_MAP_SCREENSHOT:
maplayers.append(ugettext("Services"))
if settings.SHOW_SIGNAGES_ON_MAP_SCREENSHOT:
maplayers.append(ugettext("Signages"))
if settings.SHOW_INFRASTRUCTURES_ON_MAP_SCREENSHOT:
maplayers.append(ugettext("Infrastructures"))
return {"maplayers": maplayers}
Path.add_property('treks', Trek.path_treks, _("Treks"))
Topology.add_property('treks', Trek.topology_treks, _("Treks"))
if settings.HIDE_PUBLISHED_TREKS_IN_TOPOLOGIES:
Topology.add_property('published_treks', lambda self: [], _("Published treks"))
else:
Topology.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _("Published treks"))
Intervention.add_property('treks', lambda self: self.target.treks if self.target else [], _("Treks"))
Project.add_property('treks', lambda self: self.edges_by_attr('treks'), _("Treks"))
tourism_models.TouristicContent.add_property('treks', lambda self: intersecting(Trek, self), _("Treks"))
tourism_models.TouristicContent.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _("Published treks"))
tourism_models.TouristicEvent.add_property('treks', lambda self: intersecting(Trek, self), _("Treks"))
tourism_models.TouristicEvent.add_property('published_treks', lambda self: intersecting(Trek, self).filter(published=True), _("Published treks"))
if 'geotrek.signage' in settings.INSTALLED_APPS:
Blade.add_property('treks', lambda self: self.signage.treks, _("Treks"))
Blade.add_property('published_treks', lambda self: self.signage.published_treks, _("Published treks"))
class TrekRelationshipManager(models.Manager):
use_for_related_fields = True
def get_queryset(self):
# Select treks foreign keys by default
# 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)
class TrekRelationship(models.Model):
"""
@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']
def __unicode__(self):
return self.name
@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']
def __unicode__(self):
return self.name
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
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)
.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):
code = models.CharField(primary_key=True, max_length=6, db_column='insee')
name = models.CharField(max_length=128, db_column='commune', verbose_name=_(u"Name"))
geom = models.MultiPolygonField(srid=settings.SRID, spatial_index=False)
def test_disorders_not_mandatory(self):
self.login()
data = self.get_good_data()
data.pop('disorders')
response = self.client.post(Intervention.get_add_url(), data)
self.assertEqual(response.status_code, 302)
@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']
def __unicode__(self):
return self.name
'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"))
Intervention.add_property(
'area_edges', lambda self: self.target.area_edges
if self.target and self.target else [], _("Restricted area edges"))
Intervention.add_property(
'areas', lambda self: self.target.areas
if self.target and self.target 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)),
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"))
class Meta:
db_table = 'f_b_foncier'
verbose_name = _(u"Land 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,
_("Physical edges"))
Topology.add_property('physical_edges', PhysicalEdge.topology_physicals,
_("Physical edges"))
Intervention.add_property(
'physical_edges', lambda self: self.target.physical_edges
if self.target else [], _("Physical edges"))
Project.add_property('physical_edges',
lambda self: self.edges_by_attr('physical_edges'),
_("Physical edges"))
if 'geotrek.signage' in settings.INSTALLED_APPS:
Blade.add_property('physical_edges',
lambda self: self.signage.physical_edges,
_("Physical edges"))
class LandType(StructureOrNoneRelated):
name = models.CharField(max_length=128, verbose_name=_("Name"))
right_of_way = models.BooleanField(default=False,
verbose_name=_("Right of way"))
@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,
db_column='droit_de_passage',
verbose_name=_(u"Right of way"))
class Meta:
else:
qs = cls.objects.filter(geom__intersects=topology.geom)
return qs.select_related('restricted_area')\
.select_related('restricted_area__area_type')
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)))
class City(models.Model):
code = models.CharField(primary_key=True, max_length=6, db_column='insee')
name = models.CharField(max_length=128,
db_column='commune',
verbose_name=_(u"Name"))
def test_disorders_not_mandatory(self):
self.login()
data = self.get_good_data()
data.pop('disorders')
response = self.client.post(Intervention.get_add_url(), data)
self.assertEqual(response.status_code, 302)
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")
