lostplaces-backend/django_lostplaces/lostplaces/models/place.py
Leonhard Strohmidel 3982db1375 #65 KML Import
2022-10-16 10:14:04 +02:00

283 lines
7.6 KiB
Python

import os
import datetime
from math import ceil
from django.db import models
from django.urls import reverse
from django.dispatch import receiver
from django.db.models.signals import post_delete, pre_save
from django.utils.translation import gettext as _
from django.utils import timezone
from django.conf import settings
from lostplaces.models.abstract_models import Submittable, Taggable, Mapable, Expireable
from easy_thumbnails.fields import ThumbnailerImageField
from easy_thumbnails.files import get_thumbnailer
PLACE_LEVELS = (
(1, 'Ruin'),
(2, 'Vandalized'),
(3, 'Natures Treasure'),
(4, 'Lost in History'),
(5, 'Time Capsule')
)
PLACE_MODES = (
('live', 'live'),
('draft', 'draft'),
('review', 'review'),
('archive', 'archive'),
('imported', 'imported')
)
PLACE_IMPORT_TYPES = (
('kml', 'KML-File import'),
)
class PlaceImport(models.Model):
imported_when = models.DateTimeField(
auto_now_add=True,
verbose_name=_('When the imported has taken place')
)
description = models.TextField(
default=None,
null=True,
verbose_name=_('Description of the import')
)
explorer = models.ForeignKey(
'Explorer',
null=True,
on_delete=models.SET_NULL,
related_name='place_imports'
)
import_type = models.TextField(
default='kml',
choices=PLACE_IMPORT_TYPES,
verbose_name=_('What kind of import this is')
)
class Place(Submittable, Taggable, Mapable):
"""
Place defines a lost place (location, name, description etc.).
"""
location = models.CharField(
max_length=50,
verbose_name=_('Location'),
)
description = models.TextField(
help_text=_('Description of the place: e.g. how to get there, where to be careful, the place\'s history...'),
verbose_name=_('Description'),
)
hero = models.ForeignKey(
'PlaceImage',
on_delete=models.SET_NULL,
null=True,
blank=True,
related_name='place_heros'
)
level = models.IntegerField(
default=5,
choices=PLACE_LEVELS
)
mode = models.TextField(
default='live',
choices=PLACE_MODES,
verbose_name=_('Mode of Place Editing')
)
place_import = models.ForeignKey(
PlaceImport,
null=True,
on_delete=models.SET_NULL,
related_name='place_list'
)
def is_imported(self):
return self.place_import != None
def get_hero_image(self):
if self.hero:
return self.hero
elif len(self.placeimages.all()) > 0:
return self.placeimages.first()
else:
return None
def get_absolute_url(self):
return reverse('place_detail', kwargs={'pk': self.pk})
def get_hero_index_in_queryset(self):
'''
Calculates the index of the hero image within
the list / queryset of images. Necessary for
the lightbox.
'''
for i in range(0, len(self.placeimages.all())):
image = self.placeimages.all()[i]
if image == self.hero:
return i
return None
@classmethod
# Get center position of LP-geocoordinates.
def average_latlon(cls, place_list):
amount = len(place_list)
if amount > 0:
latitude = 0
longitude = 0
for place in place_list:
longitude += place.longitude
latitude += place.latitude
return {'latitude': latitude / amount, 'longitude': longitude / amount}
else:
# Location of China Corner in Münster
# Where I almost always eat lunch
# (Does'nt help losing wheight, tho)
return {'latitude': 51.961922091398904, 'longitude': 7.6295628132604385}
def calculate_place_level(self):
if self.placevotings.count() == 0:
self.level = 5
self.save()
return
level = 0
for vote in self.placevotings.all():
level += vote.vote
self.level = round(level / self.placevotings.count())
self.save()
def calculate_voting_accuracy(self):
place_age = timezone.now() - self.submitted_when;
accuaries = [];
for vote in self.placevotings.all():
vote_age = timezone.now() - vote.submitted_when;
accuracy = 100 - (100 / (place_age / vote_age))
accuaries.append(accuracy)
if len(accuaries) > 0:
return ceil(sum(accuaries) / len(accuaries))
else:
return 0
def __str__(self):
return self.name
def generate_place_image_filename(instance, filename):
"""
Callback for generating filename for uploaded place images.
Returns filename as: place_pk-placename{-number}.jpg
"""
return settings.RELATIVE_THUMBNAIL_PATH + str(instance.place.pk) + '-' + str(instance.place.name) + '.' + filename.split('.')[-1]
def generate_image_upload_path(instance, filename):
return generate_place_image_filename(instance, filename)
class PlaceAsset(Submittable):
"""
Assets to a place, i.e. images
"""
class Meta:
abstract = True
place = models.ForeignKey(
Place,
on_delete=models.CASCADE,
related_name='%(class)ss',
null=True
)
class DummyAsset(PlaceAsset):
name = models.CharField(max_length=50)
class PlaceImage(PlaceAsset):
"""
PlaceImage defines an image file object that points to a file in uploads/.
Intermediate image sizes are generated as defined in THUMBNAIL_ALIASES.
PlaceImage references a Place to which it belongs.
"""
description = models.TextField(
blank=True,
verbose_name=_('Description'),
)
filename = ThumbnailerImageField(
upload_to=generate_place_image_filename,
resize_source=dict(size=(2560, 2560),
sharpen=True),
verbose_name=_('Images'),
help_text=_('Optional: One or more images to upload')
)
place = models.ForeignKey(
Place,
on_delete=models.CASCADE,
related_name='placeimages'
)
def __str__(self):
"""
Returning the name of the corresponding place + id
of this image as textual representation of this instance
"""
return 'Image ' + str(self.place.name)
# These two auto-delete files from filesystem when they are unneeded:
@receiver(post_delete, sender=PlaceImage)
def auto_delete_file_on_delete(sender, instance, **kwargs):
"""
Deletes file (including thumbnails) from filesystem
when corresponding `PlaceImage` object is deleted.
"""
if instance.filename:
# Get and delete all files and thumbnails from instance
thumbmanager = get_thumbnailer(instance.filename)
thumbmanager.delete(save=False)
@receiver(pre_save, sender=PlaceImage)
def auto_delete_file_on_change(sender, instance, **kwargs):
"""
Deletes old file from filesystem
when corresponding `PlaceImage` object is updated
with new file.
"""
if not instance.pk:
return False
try:
old_file = PlaceImage.objects.get(pk=instance.pk).filename
except PlaceImage.DoesNotExist:
return False
# No need to delete thumbnails, as they will be overwritten on regeneration.
new_file = instance.filename
if not old_file == new_file:
old_file.delete(save=False)
class PlaceVoting(PlaceAsset):
vote = models.IntegerField(choices=PLACE_LEVELS)
def get_human_readable_level(self):
return PLACE_LEVELS[self.vote - 1][1]
def get_all_choices(self):
return reversed(PLACE_LEVELS)