class AreaSource(models.Model):
"""A simple polygon geometry demarcating the area of a Project or Real Estate boundaries (where applicable)"""
# IDENTIFICATION
name = models.CharField(max_length=255)
# LINKS
asset = models.ForeignKey('portfolio.ProjectAsset', null=True, blank=True, on_delete=models.CASCADE)
# ATTRIBUTES
location = PolygonField()
#
# BOOKKEEPING FIELDS
#
creation_date = models.DateTimeField(auto_now_add=True)
last_change_date = models.DateTimeField(auto_now=True)
def __str__(self):
return self.name
def get_absolute_url(self):
return reverse('portfolio:AreaSource_edit', kwargs={'pk': self.pk})
class Meta:
verbose_name = "Area Source"
verbose_name_plural = "Area Sources"
def test_make_valid_output_field(self):
# output_field is GeometryField instance because different geometry
# types can be returned.
output_field = functions.MakeValid(
Value(Polygon(), PolygonField(srid=42)), ).output_field
self.assertIs(output_field.__class__, GeometryField)
self.assertEqual(output_field.srid, 42)
class ServiceAreas(models.Model):
name = models.CharField(max_length=30)
price = models.DecimalField(decimal_places=2, max_digits=10)
service_area = PolygonField(blank=False, null=False)
provider = models.ForeignKey(Providers, on_delete=models.PROTECT)
def __str__(self):
return 'Service Area:{}-{}'.format(self.id, self.name)
class ServiceArea(models.Model):
provider = models.ForeignKey(Provider, on_delete=models.CASCADE)
name = models.CharField(max_length=120)
price = MoneyField(decimal_places=3, max_digits=8)
area = PolygonField()
def __str__(self):
return f'{self.name} ({self.price})'
class GeofenceZone(models.Model):
gps = models.ForeignKey(GPSDevice, on_delete=models.CASCADE)
geom = PolygonField(srid=4326)
def __str__(self):
return str(self.id)
class Meta:
verbose_name_plural = 'GeofenceZones'
class Timezone(models.Model):
class Meta:
app_label = 'geo_timezones'
timezone = models.CharField(max_length=30)
geom = PolygonField()
objects = TimezoneManager()
def __str__(self):
return self.timezone
class Service(Model):
provider = ForeignKey(Provider, on_delete=CASCADE)
name = CharField(max_length=100)
price = DecimalField(decimal_places=4,
max_digits=6,
validators=[MinValueValidator(0)])
poly = PolygonField(blank=False, null=False)
def __str__(self):
return "{}({},{}): {}".format(self.provider.name, self.id, self.name,
self.poly)
class ServiceArea(models.Model):
name = models.CharField(max_length=80)
price = models.DecimalField(max_digits=10, decimal_places=2)
provider = models.ForeignKey(Provider, on_delete=models.CASCADE)
polygon = PolygonField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
def get_summarized(self):
return '{} ({}) - {}'.format(self.name, self.provider.name, self.price)
def __str__(self):
return self.name
class TzWorld(models.Model):
"""
table from http://efele.net/maps/tz/world/ with timezones and areas
infos; http://shisaa.jp/postset/postgis-and-postgresql-in-action-timezones.html
"""
gid = models.AutoField(primary_key=True)
tzid = models.CharField(max_length=30, blank=True)
geom = PolygonField(blank=True, null=True)
class Meta:
# managed = False
db_table = 'tz_world'
required_db_features = ['gis_enabled']
class Polygon(models.Model):
"""
A model that defines a polygon with a foreign key to Provider.
"""
name = models.CharField(
max_length=100,
verbose_name='Service Area Name',
)
price = models.DecimalField(max_digits=10, decimal_places=2)
provider = models.ForeignKey('Provider', on_delete=models.CASCADE)
geojson = PolygonField(verbose_name='Coordinates', db_index=True)
def __str__(self):
return self.name
class ServiceArea(models.Model):
class Meta:
verbose_name = "Область обслуживания"
verbose_name_plural = "Области обслуживания"
supplier = models.ForeignKey("Supplier", on_delete=models.CASCADE)
name = models.CharField("Название", max_length=255)
types = models.ManyToManyField(
ServiceType, through="TypeInArea", verbose_name="Типы обслуживания"
)
geometry = PolygonField("Область")
def __str__(self):
return str(self.name)
def get_queryset(self):
"""
This view should return a list of all the purchases
for the currently authenticated user.
"""
if not self.request.query_params.get('x1'):
raise exceptions.ValidationError(detail='x1 is required')
else:
x1 = float(self.request.query_params.get('x1'))
if not self.request.query_params.get('y1', False):
raise exceptions.ValidationError(detail='y1 is required')
else:
y1 = float(self.request.query_params.get('y1'))
if not self.request.query_params.get('x2', False):
raise exceptions.ValidationError(detail='x2 is required')
else:
x2 = float(self.request.query_params.get('x2'))
if not self.request.query_params.get('y2', False):
raise exceptions.ValidationError(detail='y2 is required')
else:
y2 = float(self.request.query_params.get('y2'))
store_queryset = Project.objects.annotate(
point=models.expressions.Func(F('longitude'),
F('latitude'),
function='ST_Point',
output_field=PointField()),
poly=models.expressions.Func(
x1,
y1,
x2,
y2,
srid=4326,
function='ST_MakeEnvelope',
output_field=PolygonField())).filter(poly__contains=F('point'))
if len(store_queryset) <= 0:
raise exceptions.ValidationError(
detail='По данному запросу нет подходящих проектов')
return store_queryset
class ServiceArea(AbstractClass):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=255, blank=False)
price = models.FloatField(blank=False)
polygon = PolygonField(blank=False)
transport_provider = models.ForeignKey(TransportationProvider)
class Ntopoly(Model):
figure = PolygonField(srid=4326, unique=True)
class Advertising(Model):
figure = PolygonField(srid=4326, unique=True)
class ServiceArea(StrMixin, models.Model):
company = models.ForeignKey(Company, on_delete=models.CASCADE)
name = models.CharField(max_length=256)
poly = PolygonField()
class SpatialCoverage(models.Model):
""" Spatial Coverage of a Keyword bound to a specifc source document"""
stelle = models.ManyToManyField(
"Stelle",
related_name='has_spatial_coverage',
blank=True,
verbose_name="Stelle",
help_text="Stelle",
).set_extra(is_public=True, )
key_word = models.ForeignKey(
"KeyWord",
related_name='has_spatial_coverage',
on_delete=models.SET_NULL,
null=True,
blank=True,
verbose_name="Stichwort",
help_text="Stichwort",
).set_extra(
is_public=True,
arche_prop="hasSubject",
)
kommentar = models.TextField(
blank=True,
null=True,
verbose_name="Kommentar",
help_text="Kommentar",
).set_extra(
is_public=True,
arche_prop="hasNote",
)
fuzzy_geom = PolygonField(
blank=True,
null=True,
verbose_name="unsichere Ortsangabe",
help_text="Ungefähre Lokalisierung einer Region",
).set_extra(
is_public=True,
arche_prop="hasWkt",
)
fuzzyness = models.IntegerField(
choices=[(i, i) for i in range(1, 11)],
blank=True,
default=1,
verbose_name="Sicherheitsindikator",
help_text="1 sehr sicher, 10 sehr unsicher").set_extra(
is_public=True, )
class Meta:
ordering = [
'id',
]
verbose_name = "Spatial Coverage"
def __str__(self):
return f"{self.stelle.all()} - {self.key_word}"
def field_dict(self):
return model_to_dict(self)
@classmethod
def get_source_table(self):
return None
@classmethod
def get_listview_url(self):
return reverse('archiv:spatialcoverage_browse')
@classmethod
def get_natural_primary_key(self):
return "id"
@classmethod
def get_createview_url(self):
return reverse('archiv:spatialcoverage_create')
def get_absolute_url(self):
return reverse('archiv:spatialcoverage_detail', kwargs={'pk': self.id})
def get_delete_url(self):
return reverse('archiv:spatialcoverage_delete', kwargs={'pk': self.id})
def get_edit_url(self):
return reverse('archiv:spatialcoverage_edit', kwargs={'pk': self.id})
def get_next(self):
next = self.__class__.objects.filter(id__gt=self.id)
if next:
return reverse('archiv:spatialcoverage_detail',
kwargs={'pk': next.first().id})
return False
def get_prev(self):
prev = self.__class__.objects.filter(id__lt=self.id).order_by('-id')
if prev:
return reverse('archiv:spatialcoverage_detail',
kwargs={'pk': prev.first().id})
return False
class Buildings(Model):
figure = PolygonField(srid=4326, unique=True)
class Route(models.Model):
"""
A route is a territory which is used to deliver a product easily, allowing us to organize the delivery of the
product for the different distributors. There are routes that are parents of other routes in hierarchy.
"""
number = models.IntegerField(primary_key=True, verbose_name=_('Number'))
name = models.CharField(max_length=40,
verbose_name=_('Name'),
blank=True,
null=True)
state = models.CharField(max_length=20,
verbose_name=_('State'),
blank=True,
null=True)
description = models.TextField(blank=True, verbose_name=_('Description'))
distributor = models.CharField(max_length=40,
blank=True,
verbose_name=_('Distributor'))
phone = models.CharField(max_length=20,
blank=True,
verbose_name=_('Phone'))
mobile = models.CharField(max_length=20,
blank=True,
verbose_name=_('Mobile'))
email = models.CharField(max_length=100,
blank=True,
verbose_name=_('Email'))
delivery_place = models.CharField(max_length=40,
blank=True,
verbose_name=_('Delivery place'))
arrival_time = models.TimeField(blank=True,
null=True,
verbose_name=_('Arrival time'))
additional_copies = models.PositiveSmallIntegerField(
default=3, verbose_name=_('Additional copies'))
directions = models.TextField(blank=True, verbose_name=_('Directions'))
distributor_directions = models.TextField(
null=True, blank=True, verbose_name=_('Distributor directions'))
notes = models.TextField(blank=True, verbose_name=_('Notes'))
beach = models.BooleanField(default=False, verbose_name=_('Beach'))
active = models.BooleanField(default=True, verbose_name=_('Active'))
print_labels = models.BooleanField(
default=True, verbose_name=_('Print labels from this route'))
price_per_copy = models.DecimalField(max_digits=10,
decimal_places=2,
blank=True,
null=True,
verbose_name=_('Price per copy'))
parent_route = models.ForeignKey('self',
related_name='child_route',
blank=True,
null=True,
verbose_name=_('Parent route'))
the_geom = PolygonField(blank=True, null=True, srid=32721)
def __unicode__(self):
return _('Route %d') % self.number
class Meta:
verbose_name = _('Route')
verbose_name_plural = _('Routes')
ordering = ('number', )
def sum_copies_per_product(self, product=None, new=False):
"""
Returns a dictionary with the total sum of products per route.
If a product is passed, then it only shows a sum of the selected product.
If "new" is passed as True, then only the people who are new subscribers (subscription date between today
and a week ago) are going to be shown.
"""
if product is None:
subprods = SubscriptionProduct.objects.filter(
route=self, subscription__active=True)
else:
subprods = SubscriptionProduct.objects.filter(
route=self, product=product, subscription__active=True)
if new:
subprods = subprods.filter(
subscription__start_date__gte=date.today() - timedelta(7))
subprods = subprods.aggregate(Sum('copies'))
return subprods['copies__sum']
def sum_promos_per_product(self, product=None):
"""
Returns a dictionary with the total sum of products per route, except it ONLY shows promotion type
subscriptions.
If a product is passed, then it only shows a sum of the selected product.
If "new" is passed as True, then only the people who are new subscribers (subscription date between today
and a week ago) are going to be shown.
"""
if product is None:
subprods = SubscriptionProduct.objects.filter(
route=self, subscription__active=True,
subscription__type='P').aggregate(Sum('copies'))
else:
subprods = SubscriptionProduct.objects.filter(
route=self,
product=product,
subscription__active=True,
subscription__type='P').aggregate(Sum('copies'))
return subprods['copies__sum']
def contacts_in_route_count(self):
"""
Returns a count of how many distinct contacts there are in this route.
"""
subprods = SubscriptionProduct.objects.filter(
route=self).distinct('subscription__contact')
return subprods.count
def invoices_in_route(self):
"""
Returns a count of how many invoices have been printed for this route, in a period between a week ago and
today.
"""
from invoicing.models import Invoice
invoices = Invoice.objects.filter(
route=self.number,
print_date__range=(date.today() - timedelta(6), date.today()),
canceled=False).count()
return invoices
def get_subscriptionproducts(self, product_id=None, isoweekday=None):
queryset = self.subscriptionproduct_set.filter(
subscription__active=True)
if product_id:
queryset = queryset.filter(product_id=product_id)
if isoweekday:
queryset = queryset.filter(product__weekday=isoweekday)
return queryset
def get_subscriptionproducts_count(self):
return self.get_subscriptionproducts().count()
def get_subscriptionproducts_today_count(self):
today_isoweekday = date.today().isoweekday()
return self.get_subscriptionproducts(
isoweekday=today_isoweekday).count()
def get_subscriptionproducts_tomorrow_count(self):
tomorrow_isoweekday = (date.today() + timedelta(1)).isoweekday()
return self.get_subscriptionproducts(
isoweekday=tomorrow_isoweekday).count()
class HapaPlaceName(models.Model):
""" Ortsname """
name = models.CharField(
max_length=250,
blank=True,
verbose_name="Name",
help_text="Standardisierte Namensansetzung",
).set_extra(
is_public=True,
arche_prop="hasTitle",
)
alternative_names = models.TextField(
blank=True,
verbose_name="Alternative Namen",
help_text="Alternative Namen, verwende '; ' als Trennzeichen",
).set_extra(
is_public=True,
arche_prop="hasAlternativeTitle",
)
historic_names = models.TextField(
blank=True,
verbose_name="Historische(r) Name(n)",
help_text="Historische(r) Name(n), verwende '; ' als Trennzeichen",
).set_extra(is_public=True, )
geonames = models.ForeignKey(
GeoNamesPlace,
related_name='rvn_hapaplacename_geonames_geonamesplace',
on_delete=models.SET_NULL,
null=True,
blank=True,
verbose_name="GeoNames Eintrag",
help_text="Name für Ort in GeoNames",
).set_extra(
is_public=True,
arche_prop="hasNonLinkedId",
arche_prop_str_template="GeoNames ID: <value>",
)
beleg = models.ManyToManyField(
"HapaBeleg",
related_name='rvn_hapaplacename_beleg_beleg',
blank=True,
verbose_name="Beleg",
help_text="Dokumentation der Belege mit ausgewählten Quellenzitaten",
).set_extra(is_public=True, )
wortbildung = RichTextField(
blank=True,
null=True,
verbose_name="Wortbildung",
help_text="Besprechung der Wortbildung des Ortsnamens",
).set_extra(is_public=True, )
etymology = RichTextField(
blank=True,
null=True,
verbose_name="Etymologie",
help_text="Besprechung der Etymologie des Ortsnamens",
).set_extra(is_public=True, )
syntax = RichTextField(
blank=True,
null=True,
verbose_name="Syntax",
help_text="Besprechung der Syntax des Ortsnamens",
).set_extra(is_public=True, )
orig_sprache = models.ForeignKey(
SkosConcept,
related_name='rvn_hapaplacename_orig_sprache_skosconcept',
on_delete=models.SET_NULL,
null=True,
blank=True,
verbose_name="Sprache",
help_text="welcher Sprache entstammt der Ortsname",
).set_extra(
is_public=True,
arche_prop="hasLanguage",
)
lat = models.FloatField(
blank=True,
null=True,
verbose_name="Breitengrad",
help_text="Latitude",
).set_extra(is_public=True, )
long = models.FloatField(
blank=True,
null=True,
verbose_name="Längengrad",
help_text="Longitude",
).set_extra(is_public=True, )
point = PointField(
blank=True,
null=True,
verbose_name="Koordinaten",
help_text="Wird aus den Angaben von Beiten- und Längengrad befüllt)",
).set_extra(
is_public=True,
arche_prop="hasWkt",
)
fuzzy_geom = PolygonField(
blank=True,
null=True,
verbose_name="Ungefähre Ortsangabe",
help_text="Ungefähre Lokalisierung historischer Orte",
).set_extra(
is_public=True,
arche_prop="hasWkt",
)
adm_unit = models.ForeignKey(
SkosConcept,
related_name='rvn_hapaplacename_adm_unit_skosconcept',
on_delete=models.SET_NULL,
null=True,
blank=True,
verbose_name="Administrative Einheit",
help_text=
"Angabe der politisch-administrativen Verortung in Region, Bezirk, Kreis, usw.",
).set_extra(is_public=True, )
historic = models.BooleanField(
default=False,
help_text=
"Historischer Ort bedeutet es gibt diesen Ort heute nicht mehr",
verbose_name="Historischer Ort")
tags = TaggableManager(blank=True)
comment = RichTextField(
blank=True,
null=True,
verbose_name="Kommentar",
help_text="Kommentar",
).set_extra(is_public=True, )
internal_comment = RichTextField(
blank=True,
null=True,
verbose_name="Kommentar (intern)",
help_text="Kommentar (intern)",
).set_extra(is_public=False, )
unclear = models.BooleanField(default=False,
help_text="Eintrag mit offenen Fragen",
verbose_name="unklar")
orig_data_csv = models.TextField(
blank=True, null=True,
verbose_name="The original data").set_extra(is_public=True)
class Meta:
ordering = [
'name',
]
verbose_name = "Ortsname"
def save(self, *args, **kwargs):
if not self.lat and self.geonames:
self.lat = self.geonames.gn_lat
self.long = self.geonames.gn_long
if self.lat and self.long and not self.point:
self.point = Point(self.long, self.lat)
if self.point:
self.long, self.lat = self.point.coord_seq[0]
super(HapaPlaceName, self).save(*args, **kwargs)
def __str__(self):
if self.name:
return "{}".format(self.name)
else:
return "{}".format(self.id)
def field_dict(self):
return model_to_dict(self)
@classmethod
def get_listview_url(self):
return reverse('archiv:hapaplacename_browse')
@classmethod
def get_source_table(self):
return None
@classmethod
def get_natural_primary_key(self):
return "id"
@classmethod
def get_createview_url(self):
return reverse('archiv:hapaplacename_create')
def get_absolute_url(self):
return reverse('archiv:hapaplacename_detail', kwargs={'pk': self.id})
def get_delete_url(self):
return reverse('archiv:hapaplacename_delete', kwargs={'pk': self.id})
def get_edit_url(self):
return reverse('archiv:hapaplacename_edit', kwargs={'pk': self.id})
def get_next(self):
next = self.__class__.objects.filter(id__gt=self.id)
if next:
return reverse('archiv:hapaplacename_detail',
kwargs={'pk': next.first().id})
return False
def get_prev(self):
prev = self.__class__.objects.filter(id__lt=self.id).order_by('-id')
if prev:
return reverse('archiv:hapaplacename_detail',
kwargs={'pk': prev.first().id})
return False
def as_geojson(self):
geom_field = 'point'
if self.fuzzy_geom:
geom_field = 'fuzzy_geom'
output = serialize('geojson',
HapaPlaceName.objects.filter(id=self.id),
geometry_field=geom_field,
fields=(
'id',
'name',
))
return json.loads(output)["features"][0]
def geojson_id(self):
return f"geojson-{self.id}"