sharix-sports/models.py

from django.db import models
from metaservicesynced.models.client import Client
from metaservicesynced.models.orders import Orders

MALE = 'M'
FEMALE = 'F'
GENDERS = [
    (MALE, 'Мужчина'),
    (FEMALE, 'Женщина'),
]

class Sportsman(models.Model):
    """
    Определяет дополнительные поля для сервиса "Друг-спортсмен".
    Дополнительные данные, связанные с функционалом пользователя.
    """
    client = models.ForeignKey(Client, on_delete=models.DO_NOTHING, help_text="клиент, которому соответствует роль спортсмена")
    bio = models.CharField(blank=True, max_length=512, help_text="")
    level = models.FloatField(default=0, help_text="")
    birthdate = models.DateField(null=True, blank=True, help_text="")
    active_status = models.CharField(max_length=64, default="Active", help_text="")
    time_updated = models.DateTimeField(blank=True, null=True, help_text="")
    preferred_time = models.CharField(max_length=128, blank=True, help_text="список дней и времени")
    reliance_rating = models.FloatField(default=0)
    # blocked_sportsman = models.ManyToManyField("self", db_table="sportsman_blocked")
    blocked_sportsman = models.ManyToManyField("self", 
                                               through="BlockedSportsman",
                                               through_fields=("sportsman", "sportsman_blocked"))
    browse_sportsman = models.ManyToManyField("self", 
                                               through="BrowseSportsman",
                                               through_fields=("sportsman", "sportsman_browsed"))
    saved_sportsman = models.ManyToManyField("self", 
                                               through="SavedSportsman",
                                               through_fields=("sportsman", "sportsman_saved"))
    sport_preferrence = models.ManyToManyField("Sport", 
                                               through="SportPreferrence",
                                               through_fields=("sportsman", "sport"))
    achievement = models.ManyToManyField("Achievements", 
                                               through="Achievement",
                                               through_fields=("sportsman", "achievement"))
    saved_event = models.ManyToManyField("Event", 
                                               through="SavedEvent",
                                               through_fields=("sportsman", "event_savedevent"))
    participant = models.ManyToManyField("Event", 
                                               through="Participant",
                                               through_fields=("sportsman", "event_participant"),
                                               related_name="sportsman_participant")
    browse_event = models.ManyToManyField("Event", 
                                               through="BrowseEvent",
                                               through_fields=("sportsman", "event_browseevent"),
                                               related_name="sportsman_browseevent")
    gender = models.CharField(max_length=1, choices=GENDERS, default=None, null=True, blank=True)



    class Meta:
        db_table = "sportsman"
        verbose_name = "Спортсмена"
        verbose_name_plural = "Спортсмены"


class Event(models.Model):
    '''
    Дополнительные данные для сервиса. Таблица основана на таблице orders
    '''
    orders = models.ForeignKey(Orders, on_delete=models.DO_NOTHING)
    sport = models.ForeignKey("Sport", on_delete=models.DO_NOTHING)
    host = models.ForeignKey("Sportsman", on_delete=models.DO_NOTHING)
    required_gender = models.CharField(max_length=1, choices=GENDERS, default=None, null=True, blank=True)
    #payment_transaction = models.ForeignKey("Payment_transaction", on_delete=models.DO_NOTHING)
    description = models.CharField(max_length=512, blank=True)
    # Event updated time
    time_updated = models.DateTimeField(auto_now=True, null=True, blank=True)
    # Time until which signing up is available
    time_close = models.DateTimeField(null=True, blank=True)
    max_participants = models.IntegerField(help_text="максимальное количесво участников")
    min_participants = models.IntegerField(help_text="минимальное количесво участников")
    max_age = models.IntegerField(help_text="максимальный возраст для участия")
    min_age = models.IntegerField(help_text="минимальный возраст для участия")
    required_level = models.IntegerField(null=True, blank=True, help_text="необходимое минимальное значение в поле level у пользователя для участия")
    location = models.CharField(max_length=100)
    event_place_start = models.CharField(max_length=128)
    event_place_finish_prediction = models.CharField(null=True, blank=True, max_length=128)
    event_place_finish_real = models.CharField(null=True, blank=True, max_length=128)
    is_public = models.BooleanField(default=True)
    #price = models.FloatField()

    class Meta:
        db_table = "event"
        verbose_name = "мероприятие"
        verbose_name_plural = "мероприятия"

        
class Sport(models.Model):
    """
    Таблица с видами спорта в сервисе
    """
    title = models.CharField(max_length=128)
    image = models.ImageField(upload_to ='sports/sport/', help_text="иконка вида спорта")
    
    class Meta:
        db_table = "sport"
        verbose_name = "вид спорта"
        verbose_name_plural = "виды спорта"


class SportPreferrence(models.Model):
    """
    Соединяющая таблица с пользователями и видами спорта, которые пользователь добавил как предпочитаемые
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_sportpreferrence")
    sport = models.ForeignKey(Sport, on_delete=models.DO_NOTHING, related_name="sport")

    class Meta:
        db_table = "sport_preferrence"
        verbose_name = "предпочитаемый вид спорта"
        verbose_name_plural = "предпочитаемые виды спорта"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'sport'], name='unique_sportpreferrence')
        ]


class EventGallery(models.Model):
    """
    Соединяющая таблица между мероприятием и картинкой для хранения картинок для конкретного мероприятия
    """
    event = models.ForeignKey(Event, on_delete=models.DO_NOTHING)
    image = models.ImageField(upload_to ='sports/event/')

    class Meta:
        db_table = "event_gallery"
        verbose_name = "фото мероприятия"
        verbose_name_plural = "фото мероприятия"


class SportsmanGallery(models.Model):
    """
    Соединяющая таблица между пользователем и картинкой для хранения картинок для конкретного пользователя
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING)
    image = models.ImageField(upload_to ='sports/sportsman/%Y/%m/%d/')

    class Meta:
        db_table = "sportsman_gallery"
        verbose_name = "фото пользователя"
        verbose_name_plural = "фото пользователя"


class Achievements(models.Model):
    """
    Achievments (not to confuse with 'Achievement') table contains a list of achievements.
    Таблицы со всеми достижениями в сервисе
    """
    title = models.CharField(max_length=128, help_text="Название достижения")
    description = models.CharField(max_length=255, help_text="Описание достижения, за что получается")
    image = models.ImageField(upload_to="sports/achievements/", help_text="статичная картинка достижения")
    image_animated = models.ImageField(null=True, blank=True, upload_to="sports/achievements/", help_text="анимированная картинка достижения. Если отсутствует, то используется статичная картинка")
    value = models.FloatField(default=0, help_text="Очки за выполение")

    class Meta:
        db_table = "achievements"
        verbose_name = "достижения"
        verbose_name_plural = "достижения"


class Achievement(models.Model):
    """
    Achievement (not to confuse with 'Achievements') stores information about achievement history of users.
    Соединяющая таблица пользователя и достижения для истории полученных достижений у конкретного пользователя.
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_achievement")
    achievement = models.ForeignKey(Achievements, on_delete=models.DO_NOTHING, related_name="achievement")
    time_received = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = "achievement"
        verbose_name = "достижение пользователя"
        verbose_name_plural = "достижения пользователя"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'achievement'], name='unique_achievement')
        ]


class SavedEvent(models.Model):
    """
    Соединяющая таблица пользователя и мероприятия для реализации функционала сохранения мероприятия в список сохранённых у конкретного пользователя
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_savedevent")
    event_savedevent = models.ForeignKey(Event, on_delete=models.DO_NOTHING, related_name="event_savedevent")

    class Meta:
        db_table = "saved_event"
        verbose_name = "сохранённое мероприятие"
        verbose_name_plural = "сохранённые мероприятия"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'event_savedevent'], name='unique_saved_event')
        ]


class SavedSportsman(models.Model):
    """
    Соединяющая таблица двух пользователей для реализации функционала сохранения пользователя в список сохранённых
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_savedsportsman")
    sportsman_saved = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_saved")

    class Meta:
        db_table = "saved_sportsman"
        verbose_name = "сохранённый ползователь"
        verbose_name_plural = "сохранённые пользователи"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'sportsman_saved'], name='unique_saved_sportsman')
        ]


class BlockedSportsman(models.Model):
    """
    Соединяющая таблица двух пользователей для реализации функционала сохранения мероприятия в список заблокированных
    """
    sportsman = models.ForeignKey(Sportsman, 
                                  on_delete=models.DO_NOTHING,
                                  related_name="sportsman_blockedsportsman")
    sportsman_blocked = models.ForeignKey(Sportsman, 
                                          on_delete=models.DO_NOTHING, 
                                          related_name="sportsman_blocked")

    class Meta:
        db_table = "blocked_sportsman"
        verbose_name = "заблокированный ползователь"
        verbose_name_plural = "заблокированные пользователи"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'sportsman_blocked'], name='unique_blocked_sportsman')
        ]   


class Participant(models.Model):
    """
    Соединяющая таблица пользователя и мероприятия для регистрации участия
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_participant")
    event_participant = models.ForeignKey(Event, on_delete=models.DO_NOTHING, related_name="event_participant")
    is_finished = models.BooleanField(default=False) # лучше такое поле или смотреть на дату окончания непосредственно в event?

    class Meta:
        db_table = "participant"
        verbose_name = "участник"
        verbose_name_plural = "участники"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'event_participant'], name='unique_participant')
        ]

   
class BrowseEvent(models.Model):
    """
    Соединяющая таблица пользователя и мероприятия для сохранения истории просмотра страниц мероприятий
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_browseevent")
    event_browseevent = models.ForeignKey(Event, on_delete=models.DO_NOTHING, related_name="event_browseevent")
    time_browsed = models.DateTimeField(auto_now_add=True, help_text="Для сортировки объектов после соединения browseEvent и browseUser")

    class Meta:
        db_table = "browse_event"
        verbose_name = "просмотренное мероприятие"
        verbose_name_plural = "просмотренные мероприятия"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'event_browseevent'], name='unique_browse_event')
        ]


class BrowseSportsman(models.Model):
    """
    Соединяющая таблица двух пользователей для сохранения истории просмотра страниц спортсменов конкретным кользователем
    """
    sportsman = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_browsesportsman")
    sportsman_browsed = models.ForeignKey(Sportsman, on_delete=models.DO_NOTHING, related_name="sportsman_browsed")
    # Для сортировки объектов после соединения browseEvent и browseUser
    time_browsed = models.DateTimeField(auto_now_add=True, help_text="Для сортировки объектов после соединения browseEvent и browseUser")

    class Meta:
        db_table = "browse_sportsman"
        verbose_name = "просмотренный пользователь"
        verbose_name_plural = "просмотренные пользователи"
        constraints = [
            models.UniqueConstraint(fields=['sportsman', 'sportsman_browsed'], name='unique_browse_sportsman')
        ]

# created events ищутся через event.host