Projects

class ProjectTypes(models.TextChoices):
    SITE_MAIN = "site_main"              # Main Metaculus site
    INDEX = "index"                      # Aggregate indices (e.g., democracy index)
    TOURNAMENT = "tournament"            # Time-bound competitions with prizes
    QUESTION_SERIES = "question_series" # Ongoing question collections
    PERSONAL_PROJECT = "personal_project" # User-created collections
    NEWS_CATEGORY = "news_category"     # News and current events
    CATEGORY = "category"               # General topic categories
    LEADERBOARD_TAG = "leaderboard_tag" # Tags for leaderboard filtering
    TOPIC = "topic"                     # Subject matter tags
    COMMUNITY = "community"             # Community-run projects

class Project(TimeStampedModel, TranslatedModel):
    type = models.CharField(max_length=32, choices=ProjectTypes.choices)
    
    # Identification
    name = models.CharField(max_length=200)
    slug = models.CharField(max_length=200, validators=[validate_alpha_slug])
    
    # Description and branding
    subtitle = models.CharField(max_length=255, blank=True, default="")
    description = models.TextField(blank=True, default="")
    header_image = models.ImageField(null=True, blank=True)
    header_logo = models.ImageField(null=True, blank=True)
    emoji = models.CharField(max_length=10, default="", blank=True)
    
    # Tournament/Competition fields
    prize_pool = models.DecimalField(decimal_places=2, max_digits=15, null=True)
    start_date = models.DateTimeField(null=True, blank=True)
    close_date = models.DateTimeField(null=True, blank=True)
    forecasting_end_date = models.DateTimeField(null=True, blank=True)
    
    # Leaderboards
    primary_leaderboard = models.ForeignKey("scoring.Leaderboard", null=True)
    
    # Permissions
    default_permission = models.CharField(choices=ObjectPermission.choices)
    override_permissions = models.ManyToManyField(User, through="ProjectUserPermission")
    created_by = models.ForeignKey(User, on_delete=models.CASCADE)
    
    # Visibility
    visibility = models.CharField(choices=Visibility.choices)
    show_on_homepage = models.BooleanField(default=False)
    
    # Metrics
    followers_count = models.PositiveIntegerField(default=0)
    forecasts_count = models.PositiveIntegerField(default=0)
    forecasters_count = models.PositiveIntegerField(default=0)

post = models.ForeignKey(
    "posts.Post",
    on_delete=models.CASCADE,
    related_name="questions",
)

# Post has:
default_project = models.ForeignKey(Project, on_delete=models.CASCADE)

projects = models.ManyToManyField(Project, related_name="posts")

default_permission = models.CharField(
    choices=ObjectPermission.choices,
    null=True,  # null -> private
    blank=True,
    default=ObjectPermission.FORECASTER,
    db_index=True,
)

class ProjectUserPermission(TimeStampedModel):
    user = models.ForeignKey(User, on_delete=models.CASCADE)
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    permission = models.CharField(choices=ObjectPermission.choices)
    
    class Meta:
        constraints = [
            models.UniqueConstraint(
                name="projectuserpermission_unique_user_id_project_id",
                fields=["user_id", "project_id"],
            ),
        ]

def annotate_user_permission(self, user: User = None):
    if user and user.is_superuser:
        return self.annotate(user_permission=models.Value(ObjectPermission.ADMIN))
    
    return self.annotate(
        user_permission=models.Case(
            models.When(
                Q(created_by_id__isnull=False, created_by_id=user_id),
                then=models.Value(ObjectPermission.ADMIN),
            ),
            default=Coalesce(
                F("_user_permission_override__permission"),
                F("default_permission"),
            ),
        ),
    )

class Visibility(models.TextChoices):
    NORMAL = "normal"
    NOT_IN_MAIN_FEED = "not_in_main_feed"
    UNLISTED = "unlisted"

show_on_homepage = models.BooleanField(default=False, db_index=True)
show_on_services_page = models.BooleanField(
    default=False, db_index=True, help_text="Show project on the Services page."
)

class ProjectIndex(TimeStampedModel):
    class IndexType(models.TextChoices):
        DEFAULT = "default"
        MULTI_YEAR = "multi_year"
    
    type = models.CharField(max_length=32, choices=IndexType.choices)
    min = models.SmallIntegerField(default=-100, help_text="Y-axis min")
    min_label = models.CharField(
        max_length=200,
        help_text='Label at minimum end. Example: "Less democratic"',
    )
    max = models.SmallIntegerField(default=100, help_text="Y-axis max")
    max_label = models.CharField(
        max_length=200,
        help_text='Label at maximum end. Example: "More democratic"',
    )
    increasing_is_good = models.BooleanField(
        default=True,
        help_text="Color polarity: if on, higher values are good (green → right)",
    )

class ProjectIndexPost(TimeStampedModel):
    index = models.ForeignKey(ProjectIndex, on_delete=models.CASCADE)
    post = models.ForeignKey("posts.Post", on_delete=models.CASCADE)
    weight = models.FloatField(
        help_text=(
            "Weight of the post within the index. "
            "If the post includes a group of questions, "
            "the same weight will be applied to all subquestions."
        ),
        default=1.0,
    )
    order = models.IntegerField(default=0)

followers_count = models.PositiveIntegerField(default=0, editable=False)
forecasts_count = models.PositiveIntegerField(default=0, editable=False)
forecasters_count = models.PositiveIntegerField(default=0, editable=False)

def update_followers_count(self):
    self.followers_count = self.subscriptions.count()

def update_forecasts_count(self):
    result = Post.objects.filter_projects(self).aggregate(
        total_forecasts=Sum("forecasts_count")
    )
    self.forecasts_count = result["total_forecasts"] or 0

def update_forecasters_count(self):
    self.forecasters_count = (
        PostUserSnapshot.objects.filter(
            last_forecast_date__isnull=False,
            user__is_staff=False,
        )
        .filter(Q(post__default_project=self) | Q(post__projects=self))
        .values("user_id")
        .distinct()
        .count()
    )

class ProjectSubscription(TimeStampedModel):
    user = models.ForeignKey(
        User, on_delete=models.CASCADE, related_name="project_subscriptions"
    )
    project = models.ForeignKey(
        Project, on_delete=models.CASCADE, related_name="subscriptions"
    )
    
    class Meta:
        constraints = [
            models.UniqueConstraint(
                name="projectsubscription_unique_user_project",
                fields=["user_id", "project_id"],
            )
        ]

Project.objects.filter_tournament()     # Tournaments and question series
Project.objects.filter_communities()    # Communities
Project.objects.filter_topic()          # Topic tags
Project.objects.filter_category()       # Category tags
Project.objects.filter_leaderboard_tags()  # Leaderboard filtering tags

# Get all projects user can access
Project.objects.filter_permission(user=user)

# Get projects where user can forecast
Project.objects.filter_permission(user=user, permission=ObjectPermission.FORECASTER)

# Get projects where user is admin
Project.objects.filter_permission(user=user, permission=ObjectPermission.ADMIN)

# Annotate with post count
Project.objects.annotate_posts_count()

# Annotate with question count
Project.objects.annotate_questions_count()

# Annotate with user's subscription status
Project.objects.annotate_is_subscribed(user=user)

# Annotate with user's permission level
Project.objects.annotate_user_permission(user=user)