+from django.contrib import admin

+

+# Register your models here.

+from django.apps import AppConfig

+

+

+class ApiConfig(AppConfig):

+    default_auto_field = 'django.db.models.BigAutoField'

+    name = 'api'

+

+    def ready(self):

+        import api.signals

+

+

+from django.core.management.base import BaseCommand

+from django.contrib.auth.models import User

+

+class Command(BaseCommand):

+    help = 'Creates a superuser.'

+

+    def handle(self, *args, **options):

+        if not User.objects.filter(username='admin').exists():

+            User.objects.create_superuser('admin', 'admin@example.com', 'admin')

+            self.stdout.write(self.style.SUCCESS('Successfully created superuser.'))

+import random

+from django.core.management.base import BaseCommand

+from django.contrib.auth.models import User

+from django.db import transaction

+from django.utils.text import slugify

+

+from api.models import Profile, Opportunity, IntroductionRequest

+

+

+class Command(BaseCommand):

+    help = "Seed demo data: users, profiles, opportunities, and intro requests."

+

+    def add_arguments(self, parser):

+        parser.add_argument(

+            "--reset",

+            action="store_true",

+            help="Delete existing demo data (profiles, opportunities, intro requests) before seeding",

+        )

+        parser.add_argument(

+            "--users",

+            type=int,

+            default=6,

+            help="Approx number of non-admin demo users to ensure exist (default: 6)",

+        )

+

+    @transaction.atomic

+    def handle(self, *args, **options):

+        reset = options["--reset"] if "--reset" in options else options.get("reset")

+        target_users = max(1, int(options.get("users", 6)))

+

+        if reset:

+            IntroductionRequest.objects.all().delete()

+            Opportunity.objects.all().delete()

+            Profile.objects.all().delete()

+            self.stdout.write(self.style.WARNING("Cleared Profiles, Opportunities, and IntroductionRequests."))

+

+        # Ensure an admin user exists

+        admin_user, created = User.objects.get_or_create(username="admin")

+        if created:

+            admin_user.set_password("admin123")

+            admin_user.is_staff = True

+            admin_user.is_superuser = True

+            admin_user.email = "admin@example.com"

+            admin_user.save()

+            self.stdout.write(self.style.SUCCESS("Created superuser 'admin' (password: admin123)"))

+        else:

+            if not admin_user.is_staff or not admin_user.is_superuser:

+                admin_user.is_staff = True

+                admin_user.is_superuser = True

+                admin_user.save(update_fields=["is_staff", "is_superuser"])

+

+        # Demo usernames to create/ensure

+        default_names = [

+            "alice",

+            "bob",

+            "charlie",

+            "diana",

+            "eve",

+            "frank",

+            "grace",

+            "heidi",

+            "ivan",

+            "judy",

+        ]

+

+        usernames = default_names[: target_users]

+        created_users = 0

+        ensured_users = []

+        for i, uname in enumerate(usernames):

+            user, u_created = User.objects.get_or_create(username=uname)

+            if u_created:

+                user.set_password("password123")

+                # Make first user staff to access admin_frontend

+                if i == 0:

+                    user.is_staff = True

+                user.email = f"{uname}@example.com"

+                user.save()

+                created_users += 1

+            ensured_users.append(user)

+

+        # Ensure Profiles for each non-admin user

+        created_profiles = 0

+        bios = [

+            "Passionate about building products and communities.",

+            "Full-stack developer and coffee enthusiast.",

+            "Marketer focused on growth and analytics.",

+            "Product designer who loves simplicity.",

+            "Data scientist exploring ML and AI.",

+            "Entrepreneur connecting people and ideas.",

+        ]

+        industries_list = [

+            "Technology",

+            "Finance",

+            "Healthcare",

+            "Education",

+            "E-commerce",

+            "Media",

+        ]

+

+        for idx, user in enumerate(ensured_users):

+            profile, p_created = Profile.objects.get_or_create(

+                user=user,

+                defaults={

+                    "bio": bios[idx % len(bios)],

+                    "interests": ", ".join(random.sample(["AI", "Web", "Cloud", "UX", "Data", "DevOps"], 3)),

+                    "industry": industries_list[idx % len(industries_list)],

+                    "is_verified": idx % 2 == 0,

+                },

+            )

+            # Also set taggit tags to mirror interests (best-effort)

+            try:

+                if profile and profile.interests:

+                    tokens = [t.strip() for t in profile.interests.split(",") if t.strip()]

+                    if tokens:

+                        profile.tags.set(tokens, clear=True)

+            except Exception:

+                pass

+            if p_created:

+                created_profiles += 1

+

+        # Ensure a few Opportunities

+        opp_titles = [

+            "Build Analytics Dashboard",

+            "Launch Marketing Campaign",

+            "Design Mobile App UI",

+            "Migrate to Cloud Infrastructure",

+            "Implement Recommendation Engine",

+        ]

+        created_opps = 0

+        for title in opp_titles:

+            opp, o_created = Opportunity.objects.get_or_create(

+                title=title,

+                defaults={

+                    "description": f"Opportunity to {title.lower()}. Help wanted from motivated contributors.",

+                },

+            )

+            if o_created:

+                created_opps += 1

+

+        # Ensure a few IntroductionRequests between different users

+        created_intros = 0

+        if len(ensured_users) >= 2:

+            pairs = []

+            for i in range(0, min(4, len(ensured_users) - 1)):

+                a = ensured_users[i]

+                b = ensured_users[-(i + 1)]

+                if a != b:

+                    pairs.append((a, b))

+            for (a, b) in pairs:

+                msg = f"Hi {b.username}, would love to connect about {random.choice(['AI', 'design', 'growth', 'data'])}."

+                exists = IntroductionRequest.objects.filter(from_user=a, to_user=b, message=msg).exists()

+                if not exists:

+                    IntroductionRequest.objects.create(

+                        from_user=a, to_user=b, message=msg, is_accepted=random.choice([False, True])

+                    )

+                    created_intros += 1

+

+        self.stdout.write(

+            self.style.SUCCESS(

+                f"Seed complete: users(+{created_users}), profiles(+{created_profiles}), opportunities(+{created_opps}), intro_requests(+{created_intros})"

+            )

+        )

+# Generated by Django 4.2.23 on 2025-08-26 13:50

+

+from django.conf import settings

+from django.db import migrations, models

+import django.db.models.deletion

+

+

+class Migration(migrations.Migration):

+

+    initial = True

+

+    dependencies = [

+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),

+    ]

+

+    operations = [

+        migrations.CreateModel(

+            name='Opportunity',

+            fields=[

+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

+                ('title', models.CharField(max_length=255)),

+                ('description', models.TextField()),

+                ('created_at', models.DateTimeField(auto_now_add=True)),

+            ],

+        ),

+        migrations.CreateModel(

+            name='Profile',

+            fields=[

+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

+                ('bio', models.TextField(blank=True)),

+                ('interests', models.CharField(blank=True, max_length=255)),

+                ('industry', models.CharField(blank=True, max_length=255)),

+                ('is_verified', models.BooleanField(default=False)),

+                ('user', models.OneToOneField(on_delete=django.db.models.deletion.CASCADE, to=settings.AUTH_USER_MODEL)),

+            ],

+        ),

+        migrations.CreateModel(

+            name='IntroductionRequest',

+            fields=[

+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

+                ('message', models.TextField()),

+                ('is_accepted', models.BooleanField(default=False)),

+                ('created_at', models.DateTimeField(auto_now_add=True)),

+                ('from_user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='sent_requests', to=settings.AUTH_USER_MODEL)),

+                ('to_user', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='received_requests', to=settings.AUTH_USER_MODEL)),

+            ],

+        ),

+    ]

+# Generated by Django 4.2.23 on 2025-08-30 14:38

+

+from django.db import migrations

+import taggit.managers

+

+

+class Migration(migrations.Migration):

+

+    dependencies = [

+        ('taggit', '0006_rename_taggeditem_content_type_object_id_taggit_tagg_content_8fc721_idx'),

+        ('api', '0001_initial'),

+    ]

+

+    operations = [

+        migrations.AddField(

+            model_name='profile',

+            name='tags',

+            field=taggit.managers.TaggableManager(blank=True, help_text='A comma-separated list of tags.', through='taggit.TaggedItem', to='taggit.Tag', verbose_name='Tags'),

+        ),

+    ]

+# Generated by Django 4.2.23 on 2025-08-31 15:01

+

+from django.conf import settings

+from django.db import migrations, models

+import django.db.models.deletion

+

+

+class Migration(migrations.Migration):

+

+    dependencies = [

+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),

+        ('api', '0002_profile_tags'),

+    ]

+

+    operations = [

+        migrations.CreateModel(

+            name='BenefitEvent',

+            fields=[

+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),

+                ('points', models.IntegerField()),

+                ('kind', models.CharField(choices=[('accepted_answer', 'Accepted Answer'), ('review_helpful', 'Review Marked Helpful'), ('referral', 'Referral'), ('recommendation', 'Recommendation')], max_length=32)),

+                ('meta', models.JSONField(blank=True, default=dict)),

+                ('created_at', models.DateTimeField(auto_now_add=True, db_index=True)),

+                ('benefactor', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='benefit_given', to=settings.AUTH_USER_MODEL)),

+                ('beneficiary', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='benefit_received', to=settings.AUTH_USER_MODEL)),

+            ],

+            options={

+                'ordering': ('-created_at', '-id'),

+                'indexes': [models.Index(fields=['benefactor', 'created_at'], name='api_benefit_benefac_a07d7f_idx'), models.Index(fields=['beneficiary', 'created_at'], name='api_benefit_benefic_2819d8_idx'), models.Index(fields=['kind', 'created_at'], name='api_benefit_kind_bdc89b_idx')],

+            },

+        ),

+    ]

+# Generated by Django 4.2.23 on 2025-08-31 15:08

+

+from django.db import migrations, models

+import django.utils.timezone

+

+

+class Migration(migrations.Migration):

+

+    dependencies = [

+        ('api', '0003_benefitevent'),

+    ]

+

+    operations = [

+        migrations.AlterField(

+            model_name='benefitevent',

+            name='created_at',

+            field=models.DateTimeField(db_index=True, default=django.utils.timezone.now),

+        ),

+    ]

+from django.db import models

+from django.contrib.auth.models import User

+from django.core.exceptions import ValidationError

+from django.utils import timezone

+from taggit.managers import TaggableManager

+

+class Profile(models.Model):

+    user = models.OneToOneField(User, on_delete=models.CASCADE)

+    bio = models.TextField(blank=True)

+    interests = models.CharField(max_length=255, blank=True)

+    industry = models.CharField(max_length=255, blank=True)

+    is_verified = models.BooleanField(default=False)

+    tags = TaggableManager(blank=True)

+

+    def __str__(self):

+        return self.user.username

+

+class Opportunity(models.Model):

+    title = models.CharField(max_length=255)

+    description = models.TextField()

+    created_at = models.DateTimeField(auto_now_add=True)

+

+    def __str__(self):

+        return self.title

+

+class IntroductionRequest(models.Model):

+    from_user = models.ForeignKey(User, related_name='sent_requests', on_delete=models.CASCADE)

+    to_user = models.ForeignKey(User, related_name='received_requests', on_delete=models.CASCADE)

+    message = models.TextField()

+    is_accepted = models.BooleanField(default=False)

+    created_at = models.DateTimeField(auto_now_add=True)

+

+    def __str__(self):

+        return f'Introduction request from {self.from_user} to {self.to_user}'

+

+

+class BenefitEvent(models.Model):

+    """Immutable ledger of user-to-user benefit/help actions.

+

+    benefactor: the user who provided value/help.

+    beneficiary: the user who received value.

+    points: positive integer weight for the action.

+    kind: action type (accepted_answer, review_helpful, referral, recommendation).

+    meta: optional JSON metadata (e.g., related object ids).

+    """

+

+    KIND_ACCEPTED_ANSWER = "accepted_answer"

+    KIND_REVIEW_HELPFUL = "review_helpful"

+    KIND_REFERRAL = "referral"

+    KIND_RECOMMENDATION = "recommendation"

+

+    KIND_CHOICES = (

+        (KIND_ACCEPTED_ANSWER, "Accepted Answer"),

+        (KIND_REVIEW_HELPFUL, "Review Marked Helpful"),

+        (KIND_REFERRAL, "Referral"),

+        (KIND_RECOMMENDATION, "Recommendation"),

+    )

+

+    benefactor = models.ForeignKey(

+        User, on_delete=models.CASCADE, related_name="benefit_given"

+    )

+    beneficiary = models.ForeignKey(

+        User, on_delete=models.CASCADE, related_name="benefit_received"

+    )

+    points = models.IntegerField()

+    kind = models.CharField(max_length=32, choices=KIND_CHOICES)

+    meta = models.JSONField(default=dict, blank=True)

+    # Use default=timezone.now so tests and backfills can set explicit timestamps

+    created_at = models.DateTimeField(default=timezone.now, db_index=True)

+

+    class Meta:

+        indexes = [

+            models.Index(fields=["benefactor", "created_at"]),

+            models.Index(fields=["beneficiary", "created_at"]),

+            models.Index(fields=["kind", "created_at"]),

+        ]

+        ordering = ("-created_at", "-id")

+

+    def clean(self):

+        if self.benefactor_id and self.beneficiary_id and self.benefactor_id == self.beneficiary_id:

+            raise ValidationError("Self-benefit is not allowed.")

+        if self.points is None or self.points <= 0:

+            raise ValidationError("Points must be a positive integer.")

+

+    def save(self, *args, **kwargs):

+        # Ensure validation always runs to enforce integrity

+        self.full_clean()

+        return super().save(*args, **kwargs)

+

+    def __str__(self):

+        return f"{self.kind} +{self.points} from {self.benefactor_id} to {self.beneficiary_id}"

+from rest_framework import serializers

+from django.contrib.auth.models import User

+from .models import Profile, Opportunity, IntroductionRequest

+from django.contrib.auth.models import User

+

+class UserSerializer(serializers.ModelSerializer):

+    class Meta:

+        model = User

+        fields = ['id', 'username', 'email']

+

+class ProfileSerializer(serializers.ModelSerializer):

+    user = UserSerializer(read_only=True)

+    tags = serializers.SerializerMethodField()

+

+    class Meta:

+        model = Profile

+        fields = ['id', 'user', 'bio', 'interests', 'industry', 'is_verified', 'tags']

+

+    def get_tags(self, obj: Profile):

+        try:

+            return list(obj.tags.names())

+        except Exception:

+            return []

+

+    

+

+class OpportunitySerializer(serializers.ModelSerializer):

+    class Meta:

+        model = Opportunity

+        fields = ['id', 'title', 'description', 'created_at']

+

+class IntroductionRequestSerializer(serializers.ModelSerializer):

+    from_user = UserSerializer(read_only=True)

+    to_user = UserSerializer(read_only=True)

+

+    class Meta:

+        model = IntroductionRequest

+        fields = ['id', 'from_user', 'to_user', 'message', 'is_accepted', 'created_at']

+

+

+class LeaderRowSerializer(serializers.Serializer):

+    rank = serializers.IntegerField()

+    user_id = serializers.IntegerField(source='id')

+    username = serializers.CharField()

+    points = serializers.IntegerField(source='points_given')

+    last_help_at = serializers.DateTimeField(allow_null=True)

+from __future__ import annotations

+

+from typing import Optional

+

+from django.contrib.auth import get_user_model

+from django.db.models import Sum, F, Max, Q, Window

+from django.db.models.functions import Rank

+from django.utils import timezone

+

+from api.models import BenefitEvent

+

+

+User = get_user_model()

+

+

+# Default weights per action kind

+BENEFIT_WEIGHTS = {

+    BenefitEvent.KIND_ACCEPTED_ANSWER: 10,

+    BenefitEvent.KIND_REVIEW_HELPFUL: 3,

+    BenefitEvent.KIND_REFERRAL: 20,

+    BenefitEvent.KIND_RECOMMENDATION: 5,

+}

+

+

+def log_benefit_event(

+    *,

+    benefactor: User,

+    beneficiary: User,

+    kind: str,

+    points: Optional[int] = None,

+    meta: Optional[dict] = None,

+) -> BenefitEvent:

+    if points is None:

+        points = BENEFIT_WEIGHTS.get(kind, 1)

+    event = BenefitEvent(

+        benefactor=benefactor,

+        beneficiary=beneficiary,

+        kind=kind,

+        points=points,

+        meta=meta or {},

+    )

+    event.save()

+    return event

+

+

+def _period_start(period: str):

+    period = (period or "").lower()

+    if period in ("all", "all_time", "alltime", ""):

+        return None

+    now = timezone.now()

+    if period in ("week", "weekly", "7d"):

+        return now - timezone.timedelta(days=7)

+    if period in ("month", "monthly", "30d"):

+        return now - timezone.timedelta(days=30)

+    # default fallback: weekly

+    return now - timezone.timedelta(days=7)

+

+

+def build_leaderboard_queryset(period: str = "weekly"):

+    start = _period_start(period)

+    pf = Q()

+    if start is not None:

+        pf = Q(benefit_given__created_at__gte=start)

+    qs = (

+        User.objects

+        .annotate(

+            points_given=Sum('benefit_given__points', filter=pf),

+            last_help_at=Max('benefit_given__created_at', filter=pf),

+        )

+    )

+    if start is not None:

+        qs = qs.filter(benefit_given__created_at__gte=start)

+    qs = (

+        qs.filter(points_given__gt=0)

+        .annotate(

+            rank=Window(

+                expression=Rank(),

+                order_by=(

+                    F('points_given').desc(nulls_last=True),

+                    F('last_help_at').asc(nulls_last=True),

+                    F('id').asc(),

+                ),

+            )

+        )

+        .order_by('rank')

+    )

+    return qs

+from __future__ import annotations

+

+from collections import Counter

+from dataclasses import dataclass

+from typing import Iterable, List, Sequence, Tuple

+

+from django.contrib.auth.models import User

+from django.db.models import Q

+from django.utils import timezone

+

+from api.models import IntroductionRequest, Opportunity, Profile

+

+

+def _now():

+    return timezone.now()

+

+

+def tokenize_interests_text(text: str | None) -> set[str]:

+    if not text:

+        return set()

+    raw = [t.strip().lower() for part in text.split(",") for t in part.split()]  # type: ignore

+    return {t for t in raw if t}

+

+

+def profile_interests(profile: Profile) -> set[str]:

+    # Prefer taggit tags when available, fall back to comma-separated string

+    try:

+        tag_names = set(t.lower() for t in profile.tags.names())

+    except Exception:

+        tag_names = set()

+    if tag_names:

+        return tag_names

+    return tokenize_interests_text(profile.interests)

+

+

+def tokenize_text(text: str | None) -> List[str]:

+    if not text:

+        return []

+    clean = "".join(ch.lower() if ch.isalnum() or ch.isspace() else " " for ch in text)

+    return [t for t in clean.split() if t]

+

+

+def jaccard(a: Iterable[str], b: Iterable[str]) -> float:

+    sa, sb = set(a), set(b)

+    if not sa and not sb:

+        return 0.0

+    inter = len(sa & sb)

+    union = len(sa | sb)

+    return inter / union if union else 0.0

+

+

+def cosine(a: Sequence[str], b: Sequence[str]) -> float:

+    if not a or not b:

+        return 0.0

+    ca, cb = Counter(a), Counter(b)

+    # dot product

+    dot = sum(ca[t] * cb.get(t, 0) for t in ca)

+    if dot == 0:

+        return 0.0

+    import math

+

+    na = math.sqrt(sum(v * v for v in ca.values()))

+    nb = math.sqrt(sum(v * v for v in cb.values()))

+    denom = na * nb

+    return (dot / denom) if denom else 0.0

+

+

+def time_decay(ts, half_life_days: float = 7.0) -> float:

+    if not ts:

+        return 0.0

+    import math

+

+    dt = (_now() - ts).total_seconds()

+    half_life = half_life_days * 24 * 3600.0

+    if dt <= 0:

+        return 1.0

+    return math.pow(0.5, dt / half_life)

+

+

+def neighbor_set(u: User) -> set[int]:

+    # Users this user has interacted with via introduction requests

+    ids = set(

+        IntroductionRequest.objects.filter(Q(from_user=u) | Q(to_user=u))

+        .values_list("from_user_id", "to_user_id")

+    )

+    # Flatten and drop self id

+    flat = {i for pair in ids for i in pair if i and i != u.id}

+    return flat

+

+

+def graph_similarity(u: User, v: User) -> float:

+    nu, nv = neighbor_set(u), neighbor_set(v)

+    return jaccard(nu, nv)

+

+

+def has_existing_request(u: User, v: User) -> bool:

+    return IntroductionRequest.objects.filter(

+        (Q(from_user=u, to_user=v) | Q(from_user=v, to_user=u))

+    ).exists()

+

+

+@dataclass

+class RankedProfile:

+    profile: Profile

+    score: float

+

+

+def rank_users_for(user: User, k: int = 20) -> List[RankedProfile]:

+    try:

+        me_profile = Profile.objects.select_related("user").get(user=user)

+    except Profile.DoesNotExist:

+        me_profile = Profile(user=user)  # empty defaults

+

+    my_interests = profile_interests(me_profile)

+    ranked: List[Tuple[float, Profile]] = []

+

+    qs = (

+        Profile.objects.select_related("user")

+        .exclude(user=user)

+    )

+

+    for p in qs.iterator():

+        if has_existing_request(user, p.user):

+            continue

+

+        jac = jaccard(my_interests, profile_interests(p))

+        # Industry match: exact string match and non-empty

+        industry_match = 1.0 if (me_profile.industry and me_profile.industry == p.industry) else 0.0

+        ver = 1.0 if p.is_verified else 0.0

+        gsim = graph_similarity(user, p.user)

+

+        # Candidate activity recency: last accepted intro involving candidate

+        last_acc = (

+            IntroductionRequest.objects.filter(

+                Q(from_user=p.user) | Q(to_user=p.user), is_accepted=True

+            )

+            .order_by("-created_at")

+            .values_list("created_at", flat=True)

+            .first()

+        )

+        rec = time_decay(last_acc) if last_acc else 0.0

+

+        score = 0.45 * jac + 0.15 * industry_match + 0.20 * gsim + 0.10 * ver + 0.10 * rec

+        if score > 0:

+            ranked.append((score, p))

+

+    ranked.sort(key=lambda t: t[0], reverse=True)

+    top = ranked[:k]

+    return [RankedProfile(profile=p, score=s) for s, p in top]

+

+

+@dataclass

+class RankedOpportunity:

+    opportunity: Opportunity

+    score: float

+

+

+def rank_opportunities_for(user: User, k: int = 20) -> List[RankedOpportunity]:

+    try:

+        me_profile = Profile.objects.select_related("user").get(user=user)

+    except Profile.DoesNotExist:

+        me_profile = Profile(user=user)  # empty defaults

+

+    query_tokens = tokenize_text((me_profile.bio or "") + " " + (me_profile.interests or "") + " " + (me_profile.industry or ""))

+

+    ranked: List[Tuple[float, Opportunity]] = []

+    for o in Opportunity.objects.all().iterator():

+        doc_tokens = tokenize_text(o.title + " " + (o.description or ""))

+        sim = cosine(query_tokens, doc_tokens)

+        freshness = time_decay(o.created_at, half_life_days=10.0)

+        score = 0.6 * sim + 0.4 * freshness

+        if score > 0:

+            ranked.append((score, o))

+

+    ranked.sort(key=lambda t: t[0], reverse=True)

+    top = ranked[:k]

+    return [RankedOpportunity(opportunity=o, score=s) for s, o in top]

+from django.db.models.signals import post_save

+from django.contrib.auth.models import User

+from django.dispatch import receiver

+from .models import Profile

+

+@receiver(post_save, sender=User)

+def create_profile(sender, instance, created, **kwargs):

+    if created:

+        Profile.objects.create(user=instance)

+from django.test import TestCase

+from django.contrib.auth.models import User

+from rest_framework.test import APIClient

+from django.utils import timezone

+

+from api.models import Profile, Opportunity, IntroductionRequest, BenefitEvent

+from api.services.matching import (

+    jaccard,

+    cosine,

+    tokenize_interests_text,

+    rank_users_for,

+    rank_opportunities_for,

+)

+from api.services.benefit import log_benefit_event, build_leaderboard_queryset

+

+

+class SimilarityUtilsTests(TestCase):

+    def test_tokenize_and_jaccard(self):

+        a = tokenize_interests_text("AI, Data Science")

+        b = tokenize_interests_text("data science, analytics")

+        self.assertGreater(jaccard(a, b), 0)

+        self.assertLessEqual(jaccard(a, b), 1)

+

+    def test_cosine(self):

+        self.assertAlmostEqual(cosine(["ai", "ai"], ["ai"]) > 0, True)

+        self.assertEqual(cosine(["a"], ["b"]), 0.0)

+

+

+class MatchingServiceTests(TestCase):

+    def setUp(self):

+        # Users

+        self.u1 = User.objects.create_user(username="alice", password="x")

+        self.u2 = User.objects.create_user(username="bob", password="x")

+        self.u3 = User.objects.create_user(username="carol", password="x")

+

+        # Profiles (user post_save signal creates a default Profile; update it)

+        self.p1 = Profile.objects.get(user=self.u1)

+        self.p1.bio = "Loves AI and data"

+        self.p1.interests = "AI, Data"

+        self.p1.is_verified = True

+        self.p1.save()

+

+        self.p2 = Profile.objects.get(user=self.u2)

+        self.p2.bio = "AI researcher"

+        self.p2.interests = "AI, ML"

+        self.p2.save()

+

+        self.p3 = Profile.objects.get(user=self.u3)

+        self.p3.bio = "Designer"

+        self.p3.interests = "UX, UI"

+        self.p3.save()

+

+        # Taggit tags (best-effort; fine if taggit not fully migrated yet)

+        try:

+            self.p1.tags.set(["ai", "data"])  # prefer tags in matching

+            self.p2.tags.set(["ai", "ml"])

+            self.p3.tags.set(["ux", "ui"])

+        except Exception:

+            pass

+        self.p1.industry = "Technology"

+        self.p2.industry = "Technology"

+        self.p3.industry = "Design"

+        self.p1.save(); self.p2.save(); self.p3.save()

+

+        # Opportunity

+        self.o1 = Opportunity.objects.create(title="Build Analytics Dashboard", description="Work with data and AI dashboards")

+

+    def test_rank_users_for_returns_scored_results(self):

+        ranked = rank_users_for(self.u1, k=5)

+        self.assertTrue(any(r.profile.user == self.u2 for r in ranked))

+        # Existing request excludes candidate

+        IntroductionRequest.objects.create(from_user=self.u1, to_user=self.u2, message="hi")

+        ranked2 = rank_users_for(self.u1, k=5)

+        self.assertFalse(any(r.profile.user == self.u2 for r in ranked2))

+

+    def test_rank_opportunities_for_uses_text_similarity(self):