stolen/app/models.py

from django.db import models
from django.utils.text import slugify
from django.contrib.auth.models import User
from django.urls import reverse, reverse_lazy
from django.dispatch import receiver
from django.db.models.signals import post_save
from django.core.validators import MinValueValidator

import uuid
import os
import random

from phonenumber_field.modelfields import PhoneNumberField
from django_mysql.models import JSONField

import gdpr_assist

ITEM_STATUS_CHOICES = [
    (-1, "Not public"),
    (0, "Not stolen"),
    (1, "Stolen"),
    (2, "Legal change of ownership")
]

REPORT_STATUS_CHOICES = [
    (-1, "Invalid"),
    (0, "Unprocessed"),
    (1, "Processing"),
    (2, "Processed")
]

class UserPrivacyMeta:
    fields = [ "first_name", "last_name", "email" ]

gdpr_assist.register(User, UserPrivacyMeta)

def get_file_path(instance, filename):
    ext = filename.split('.')[-1]
    filename = "%s.%s" % (uuid.uuid4(), ext)
    return os.path.join('uploads/images/', filename)

def generateIID():
    return ''.join(["%i" % random.randint(0, 9) for _ in range(0, 10)])

class Category(models.Model):
    name = models.CharField(max_length=64)
    slug = models.SlugField(primary_key=True, max_length=64)

    def save(self, *args, **kwargs):
        if not self.slug:
            self.slug = slugify(self.name)
        super(Category, self).save(*args, **kwargs)

    def __str__(self):
        return self.name

class Item(models.Model):
    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4)
    iid = models.CharField(max_length=10, unique=True, default=generateIID)
    name = models.CharField(max_length=128)
    description = models.TextField("Beschreibung", max_length=2048)
    owner = models.ForeignKey(User, on_delete=models.CASCADE)
    cats = models.ManyToManyField(Category, verbose_name="Kategorien")
    status = models.IntegerField(choices=ITEM_STATUS_CHOICES, default=-1)
    stolen_on = models.DateTimeField("Zeitpunkt des Diebstahls", null=True, blank=True)
    stolen_at = JSONField("Ort des Diebstahls", null=True, blank=True)
    reward = models.DecimalField("Belohnung für Finder in Euro (mindestens 300)", default=300, max_digits=10, decimal_places=2, validators=[MinValueValidator(300)])
    serial = models.CharField("Seriennummer", max_length=128, null=True, blank=True)

    def reset_status(self):
        self.status = 0

    def get_absolute_url(self):
        return reverse("edititem", kwargs={'uuid': self.uuid})

    def get_primary_image(self):
        try:
            return self.image_set.get(primary=True)
        except:
            try:
                return self.image_set.all()[0]
            except:
                return False

    def get_status_html(self):
        if self.status == -1:
          return '<span style="color: orange;">Noch nicht freigeschaltet!</span>'
        if self.status == 0:
          return '<span style="color: green;">Nicht als gestohlen gemeldet.</span>'
        if self.status == 1:
          return '<span style="color: red;">Als gestohlen gemeldet!</span>'
        if self.status == 2:
          return '<span style="color: blue;">Gegenstand verkauft</span>'

class Image(models.Model):
    image = models.ImageField("Bilddatei", upload_to=get_file_path)
    item = models.ForeignKey(Item, on_delete=models.CASCADE)
    description = models.TextField("Beschreibung", null=True, blank=True)
    primary = models.BooleanField("Als Hauptbild festlegen", default=False)

    def set_primary_image(self):
        try:
            old = item.image_set.get(primary=True)
            old.primary = False
            old.save()
        except:
            pass

        self.primary = True
        self.save()

    def get_absolute_url(self):
        return reverse_lazy("edititem", kwargs={'uuid': self.item.uuid})

class UserProfile(models.Model):
    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4)
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    avatar = models.ImageField(null=True, blank=True)
    company = models.CharField(max_length=64, null=True, blank=True)
    address = models.TextField(null=True, blank=True, max_length=128)
    zipcode = models.CharField(max_length=16, null=True, blank=True)
    city = models.CharField(max_length=128, null=True, blank=True)
    country = models.CharField(max_length=32, null=True, blank=True)
    mobile = PhoneNumberField(null=True, blank=True)

    class PrivacyMeta:
        fields = [ "avatar", "company", "address", "zipcode", "city", "country", "mobile" ]

class Report(models.Model):
    uuid = models.UUIDField(primary_key=True, default=uuid.uuid4)
    name = models.CharField(max_length=128)
    mail = models.EmailField("E-Mail")
    phone = PhoneNumberField("Telefon")
    found_on = models.DateTimeField("Fundzeitpunkt")
    found_at = JSONField("Fundort")
    message = models.TextField("Details")
    item = models.ForeignKey(Item, on_delete=models.CASCADE)
    created = models.DateTimeField(auto_now_add=True)
    status = models.IntegerField(choices=REPORT_STATUS_CHOICES, default=0)

    def get_status_html(self):
        if self.status == 0:
          return '<span style="color: blue;">Unbeantwortet</span>'
        if self.status == 1:
          return '<span style="color: orange;">In Beantwortung</span>'
        if self.status == 2:
          return '<span style="color: green;">Bearbeitet</span>'
        if self.status == -1:
          return '<span style="color: red;">Abgelehnt</span>'

    def get_absolute_url(self):
        return reverse_lazy("report", kwargs={'uuid': self.uuid})

    class PrivacyMeta:
        fields = [ "name", "mail", "phone", "found_on", "found_at", "message" ]

class ReportImage(models.Model):
    image = models.ImageField()
    report = models.ForeignKey(Report, on_delete=models.CASCADE)

    def get_absolute_url(self):
        return reverse_lazy("reportimages", kwargs={'report': self.report.id})

    class PrivacyMeta:
        fields = [ "image" ]

@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if kwargs.get('created', True) and not kwargs.get('raw', False):
        try:
            UserProfile.objects.create(user=instance)
        except:
            pass

@receiver(gdpr_assist.signals.pre_anonymise, sender=User)
def anonymise_profile(sender, instance, **kwargs):
    instance.userprofile.anonymise()