370 lines
13 KiB
Python
370 lines
13 KiB
Python
from django.db import models
|
|
from polymorphic.models import PolymorphicModel
|
|
from users.models import User
|
|
from catalog.common.models import Item, ItemCategory
|
|
from catalog.common.mixins import SoftDeleteMixin
|
|
from .mixins import UserOwnedObjectMixin
|
|
from catalog.collection.models import Collection as CatalogCollection
|
|
from decimal import *
|
|
from enum import Enum
|
|
from markdownx.models import MarkdownxField
|
|
from django.utils import timezone
|
|
from django.conf import settings
|
|
from django.core.validators import MaxValueValidator, MinValueValidator
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.core.validators import RegexValidator
|
|
from functools import cached_property
|
|
from django.db.models import Count
|
|
import django.dispatch
|
|
|
|
|
|
class Piece(PolymorphicModel, UserOwnedObjectMixin):
|
|
owner = models.ForeignKey(User, on_delete=models.PROTECT)
|
|
visibility = models.PositiveSmallIntegerField(default=0) # 0: Public / 1: Follower only / 2: Self only
|
|
created_time = models.DateTimeField(auto_now_add=True)
|
|
edited_time = models.DateTimeField(auto_now=True)
|
|
is_deleted = models.BooleanField(default=False, db_index=True)
|
|
metadata = models.JSONField(default=dict)
|
|
attached_to = models.ForeignKey(User, null=True, default=None, on_delete=models.SET_NULL, related_name="attached_with")
|
|
|
|
|
|
class Content(SoftDeleteMixin, Piece):
|
|
item: models.ForeignKey(Item, on_delete=models.PROTECT)
|
|
|
|
def __str__(self):
|
|
return f"{self.id}({self.item})"
|
|
|
|
|
|
class Note(Content):
|
|
pass
|
|
|
|
|
|
class Review(Content):
|
|
warning = models.BooleanField(default=False)
|
|
title = models.CharField(max_length=500, blank=False, null=True)
|
|
body = MarkdownxField()
|
|
pass
|
|
|
|
|
|
class Rating(Content):
|
|
grade = models.IntegerField(default=0, validators=[MaxValueValidator(10), MinValueValidator(0)])
|
|
|
|
|
|
class Reply(Content):
|
|
reply_to_content = models.ForeignKey(Content, on_delete=models.PROTECT, related_name='replies')
|
|
title = models.CharField(max_length=500, null=True)
|
|
body = MarkdownxField()
|
|
pass
|
|
|
|
|
|
"""
|
|
List (abstract class)
|
|
"""
|
|
|
|
list_add = django.dispatch.Signal()
|
|
list_remove = django.dispatch.Signal()
|
|
|
|
|
|
class List(Piece):
|
|
class Meta:
|
|
abstract = True
|
|
|
|
_owner = models.ForeignKey(User, on_delete=models.PROTECT) # duplicated owner field to make unique key possible for subclasses
|
|
|
|
def save(self, *args, **kwargs):
|
|
self._owner = self.owner
|
|
super().save(*args, **kwargs)
|
|
|
|
# MEMBER_CLASS = None # subclass must override this
|
|
# subclass must add this:
|
|
# items = models.ManyToManyField(Item, through='ListMember')
|
|
|
|
@property
|
|
def ordered_members(self):
|
|
return self.members.all().order_by('position', 'item_id')
|
|
|
|
@property
|
|
def ordered_items(self):
|
|
return self.items.all().order_by(self.MEMBER_CLASS.__name__.lower() + '__position')
|
|
|
|
def has_item(self, item):
|
|
return self.members.filter(item=item).count() > 0
|
|
|
|
def append_item(self, item, **params):
|
|
if item is None or self.has_item(item):
|
|
return None
|
|
else:
|
|
ml = self.ordered_members
|
|
p = {'_' + self.__class__.__name__.lower(): self}
|
|
p.update(params)
|
|
member = self.MEMBER_CLASS.objects.create(owner=self.owner, position=ml.last().position + 1 if ml.count() else 1, item=item, **p)
|
|
list_add.send(sender=self.__class__, instance=self, item=item, member=member)
|
|
return member
|
|
|
|
def remove_item(self, item):
|
|
member = self.members.all().filter(item=item).first()
|
|
list_remove.send(sender=self.__class__, instance=self, item=item, member=member)
|
|
if member:
|
|
member.delete()
|
|
|
|
def move_up_item(self, item):
|
|
members = self.ordered_members
|
|
member = members.filter(item=item).first()
|
|
if member:
|
|
other = members.filter(position__lt=member.position).last()
|
|
if other:
|
|
p = other.position
|
|
other.position = member.position
|
|
member.position = p
|
|
other.save()
|
|
member.save()
|
|
|
|
def move_down_item(self, item):
|
|
members = self.ordered_members
|
|
member = members.filter(item=item).first()
|
|
if member:
|
|
other = members.filter(position__gt=member.position).first()
|
|
if other:
|
|
p = other.position
|
|
other.position = member.position
|
|
member.position = p
|
|
other.save()
|
|
member.save()
|
|
|
|
|
|
class ListMember(Piece):
|
|
"""
|
|
ListMember - List class's member class
|
|
It's an abstract class, subclass must add this:
|
|
|
|
_list = models.ForeignKey('ListClass', related_name='members', on_delete=models.CASCADE)
|
|
|
|
it starts with _ bc Django internally created OneToOne Field on Piece
|
|
https://docs.djangoproject.com/en/3.2/topics/db/models/#specifying-the-parent-link-field
|
|
"""
|
|
item = models.ForeignKey(Item, on_delete=models.PROTECT)
|
|
position = models.PositiveIntegerField()
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
def __str__(self):
|
|
return f'{self.id}:{self.position} ({self.item})'
|
|
|
|
|
|
"""
|
|
Shelf
|
|
"""
|
|
|
|
|
|
class ShelfType(models.TextChoices):
|
|
WISHED = ('wished', '未开始')
|
|
STARTED = ('started', '进行中')
|
|
DONE = ('done', '完成')
|
|
# DISCARDED = ('discarded', '放弃')
|
|
|
|
|
|
ShelfTypeNames = [
|
|
[ItemCategory.Book, ShelfType.WISHED, _('想读')],
|
|
[ItemCategory.Book, ShelfType.STARTED, _('在读')],
|
|
[ItemCategory.Book, ShelfType.DONE, _('读过')],
|
|
[ItemCategory.Movie, ShelfType.WISHED, _('想看')],
|
|
[ItemCategory.Movie, ShelfType.STARTED, _('在看')],
|
|
[ItemCategory.Movie, ShelfType.DONE, _('看过')],
|
|
[ItemCategory.TV, ShelfType.WISHED, _('想看')],
|
|
[ItemCategory.TV, ShelfType.STARTED, _('在看')],
|
|
[ItemCategory.TV, ShelfType.DONE, _('看过')],
|
|
[ItemCategory.Music, ShelfType.WISHED, _('想听')],
|
|
[ItemCategory.Music, ShelfType.STARTED, _('在听')],
|
|
[ItemCategory.Music, ShelfType.DONE, _('听过')],
|
|
[ItemCategory.Game, ShelfType.WISHED, _('想玩')],
|
|
[ItemCategory.Game, ShelfType.STARTED, _('在玩')],
|
|
[ItemCategory.Game, ShelfType.DONE, _('玩过')],
|
|
[ItemCategory.Collection, ShelfType.WISHED, _('关注')],
|
|
# TODO add more combinations
|
|
]
|
|
|
|
|
|
class ShelfMember(ListMember):
|
|
_shelf = models.ForeignKey('Shelf', related_name='members', on_delete=models.CASCADE)
|
|
|
|
|
|
class Shelf(List):
|
|
class Meta:
|
|
unique_together = [['_owner', 'item_category', 'shelf_type']]
|
|
|
|
MEMBER_CLASS = ShelfMember
|
|
items = models.ManyToManyField(Item, through='ShelfMember', related_name="+")
|
|
item_category = models.CharField(choices=ItemCategory.choices, max_length=100, null=False, blank=False)
|
|
shelf_type = models.CharField(choices=ShelfType.choices, max_length=100, null=False, blank=False)
|
|
|
|
def __str__(self):
|
|
return f'{self.id} {self.title}'
|
|
|
|
@cached_property
|
|
def shelf_type_name(self):
|
|
return next(iter([n[2] for n in iter(ShelfTypeNames) if n[0] == self.item_category and n[1] == self.shelf_type]), self.shelf_type)
|
|
|
|
@cached_property
|
|
def title(self):
|
|
q = _("{item_category} {shelf_type_name} list").format(shelf_type_name=self.shelf_type_name, item_category=self.item_category)
|
|
return _("{user}'s {shelf_name}").format(user=self.owner.mastodon_username, shelf_name=q)
|
|
|
|
|
|
class ShelfLogEntry(models.Model):
|
|
owner = models.ForeignKey(User, on_delete=models.PROTECT)
|
|
shelf = models.ForeignKey(Shelf, on_delete=models.PROTECT, related_name='entries', null=True) # None means removed from any shelf
|
|
item = models.ForeignKey(Item, on_delete=models.PROTECT)
|
|
timestamp = models.DateTimeField(default=timezone.now) # this may later be changed by user
|
|
metadata = models.JSONField(default=dict)
|
|
created_time = models.DateTimeField(auto_now_add=True)
|
|
edited_time = models.DateTimeField(auto_now=True)
|
|
|
|
def __str__(self):
|
|
return f'{self.owner}:{self.shelf}:{self.item}:{self.metadata}'
|
|
|
|
|
|
class ShelfManager:
|
|
"""
|
|
ShelfManager
|
|
|
|
all shelf operations should go thru this class so that ShelfLogEntry can be properly populated
|
|
ShelfLogEntry can later be modified if user wish to change history
|
|
"""
|
|
|
|
def __init__(self, user):
|
|
self.owner = user
|
|
|
|
def initialize(self):
|
|
for ic in ItemCategory:
|
|
for qt in ShelfType:
|
|
Shelf.objects.create(owner=self.owner, item_category=ic, shelf_type=qt)
|
|
|
|
def _shelf_member_for_item(self, item):
|
|
return ShelfMember.objects.filter(item=item, _shelf__in=self.owner.shelf_set.all()).first()
|
|
|
|
def _shelf_for_item_and_type(item, shelf_type):
|
|
if not item or not shelf_type:
|
|
return None
|
|
return self.owner.shelf_set.all().filter(item_category=item.category, shelf_type=shelf_type)
|
|
|
|
def move_item(self, item, shelf_type, visibility=0, metadata=None):
|
|
# shelf_type=None means remove from current shelf
|
|
# metadata=None means no change
|
|
if not item:
|
|
raise ValueError('empty item')
|
|
lastqm = self._shelf_member_for_item(item)
|
|
lastqmm = lastqm.metadata if lastqm else None
|
|
lastq = lastqm._shelf if lastqm else None
|
|
lastqt = lastq.shelf_type if lastq else None
|
|
shelf = self.get_shelf(item.category, shelf_type) if shelf_type else None
|
|
if lastq != shelf:
|
|
if lastq:
|
|
lastq.remove_item(item)
|
|
if shelf:
|
|
shelf.append_item(item, visibility=visibility, metadata=metadata or {})
|
|
elif metadata is not None:
|
|
lastqm.metadata = metadata
|
|
lastqm.save()
|
|
elif lastqm:
|
|
metadata = lastqm.metadata
|
|
if lastqt != shelf_type or (lastqt and metadata != lastqmm):
|
|
ShelfLogEntry.objects.create(owner=self.owner, shelf=shelf, item=item, metadata=metadata or {})
|
|
|
|
def get_log(self):
|
|
return ShelfLogEntry.objects.filter(owner=self.owner).order_by('timestamp')
|
|
|
|
def get_log_for_item(self, item):
|
|
return ShelfLogEntry.objects.filter(owner=self.owner, item=item).order_by('timestamp')
|
|
|
|
def get_shelf(self, item_category, shelf_type):
|
|
return self.owner.shelf_set.all().filter(item_category=item_category, shelf_type=shelf_type).first()
|
|
|
|
@staticmethod
|
|
def get_manager_for_user(user):
|
|
return ShelfManager(user)
|
|
|
|
|
|
User.shelf_manager = cached_property(ShelfManager.get_manager_for_user)
|
|
User.shelf_manager.__set_name__(User, 'shelf_manager')
|
|
|
|
|
|
"""
|
|
Collection
|
|
"""
|
|
|
|
|
|
class CollectionMember(ListMember):
|
|
_collection = models.ForeignKey('Collection', related_name='members', on_delete=models.CASCADE)
|
|
|
|
|
|
class Collection(List):
|
|
MEMBER_CLASS = CollectionMember
|
|
catalog_item = models.OneToOneField(CatalogCollection, on_delete=models.PROTECT)
|
|
title = models.CharField(_("title in primary language"), max_length=1000, default="")
|
|
brief = models.TextField(_("简介"), blank=True, default="")
|
|
items = models.ManyToManyField(Item, through='CollectionMember', related_name="collections")
|
|
collaborative = models.PositiveSmallIntegerField(default=0) # 0: Editable by owner only / 1: Editable by bi-direction followers
|
|
|
|
@property
|
|
def plain_description(self):
|
|
html = markdown(self.description)
|
|
return RE_HTML_TAG.sub(' ', html)
|
|
|
|
def save(self, *args, **kwargs):
|
|
if getattr(self, 'catalog_item', None) is None:
|
|
self.catalog_item = CatalogCollection()
|
|
if self.catalog_item.title != self.title or self.catalog_item.brief != self.brief:
|
|
self.catalog_item.title = self.title
|
|
self.catalog_item.brief = self.brief
|
|
self.catalog_item.save()
|
|
super().save(*args, **kwargs)
|
|
|
|
|
|
"""
|
|
Tag
|
|
"""
|
|
|
|
|
|
class TagMember(ListMember):
|
|
_tag = models.ForeignKey('Tag', related_name='members', on_delete=models.CASCADE)
|
|
|
|
|
|
TagValidators = [RegexValidator(regex=r'\s+', inverse_match=True)]
|
|
|
|
|
|
class Tag(List):
|
|
MEMBER_CLASS = TagMember
|
|
items = models.ManyToManyField(Item, through='TagMember')
|
|
title = models.CharField(max_length=100, null=False, blank=False, validators=TagValidators)
|
|
# TODO case convert and space removal on save
|
|
# TODO check on save
|
|
|
|
class Meta:
|
|
unique_together = [['_owner', 'title']]
|
|
|
|
@staticmethod
|
|
def cleanup_title(title):
|
|
return title.strip().lower()
|
|
|
|
@staticmethod
|
|
def public_tags_for_item(item):
|
|
tags = item.tag_set.all().filter(visibility=0).values('title').annotate(frequency=Count('owner')).order_by('-frequency')
|
|
return list(map(lambda t: t['title'], tags))
|
|
|
|
@staticmethod
|
|
def all_tags_for_user(user):
|
|
tags = user.tag_set.all().values('title').annotate(frequency=Count('members')).order_by('-frequency')
|
|
return list(map(lambda t: t['title'], tags))
|
|
|
|
@staticmethod
|
|
def add_tag_by_user(item, tag_title, user, default_visibility=0):
|
|
title = Tag.cleanup_title(tag_title)
|
|
tag = Tag.objects.filter(owner=user, title=title).first()
|
|
if not tag:
|
|
tag = Tag.objects.create(owner=user, title=title, visibility=default_visibility)
|
|
tag.append_item(item)
|
|
|
|
|
|
Item.tags = property(Tag.public_tags_for_item)
|
|
User.tags = property(Tag.all_tags_for_user)
|