backend django-sentiment-project-arch

Mülakat Duygu Analizi Platformu — Plan Spesifikasyonu

1. Ön Yüz (Frontend)

1.1 User-Login Ekranı (kod ile)

Detay: Django'nun built-in django.contrib.auth sistemi ile username/password login.

Olası Pürüz	Açıklama	Çözüm Önerisi
Session güvenliği	CSRF, session hijacking riski	Django `{% csrf_token %}` + `SESSION_COOKIE_HTTPONLY = True` + `SECURE_SSL_REDIRECT` (prod)
Şifre politikası	Zayıf şifre kabul edilebilir	`AUTH_PASSWORD_VALIDATORS` ayarlarını aktif et
Başarısız giriş saldırısı	Brute-force denemeleri	`django-axes` veya basit rate-limiting middleware ekle

[!TIP] Alternatif: İleride OAuth2 (Google/Microsoft) eklemek isterseniz django-allauth paketini şimdiden entegre etmek kolaydır. Şu an için gerek yok ama DB şemasını buna uyumlu tutmak avantajlı olur.

1.2 Mülakat Başlat / Bitir Butonları

Detay: Tek sayfa üzerinde "Başlat" ve "Bitir" butonları. Başlat → kamerayı aç + WebRTC bağlantısını kur + soruları göster + backend'e session başlat sinyali gönder. Bitir → WebRTC bağlantısını kapat + her şeyi durdur + session'ı kapat.

Olası Pürüz	Açıklama	Çözüm Önerisi
Kamera izni reddedilirse	Kullanıcı tarayıcıda izin vermezse akış kırılır	`getUserMedia` hata yakalama ile kullanıcıya uyarı göster, başlat butonunu devre dışı bırak
Çift tıklama / race condition	"Başlat"a iki kez basılırsa birden fazla session açılır	Butonu tıklandığında disable et, backend'den cevap gelince tekrar aktif et
Sayfa yenileme / kaza kapanması	Mülakat ortasında sekme kapanırsa veri kaybı	`beforeunload` event'i ile uyarı göster + backend tarafında "orphan session" temizleme mekanizması (cron/celery task)
Video akışı kesintisi	Internet veya kamera kopması	WebRTC `oniceconnectionstatechange` event'i ile bağlantı durumu takibi, kesilirse kullanıcıya bildirim + otomatik yeniden bağlanma (ICE restart)

[!IMPORTANT] Öneri: Butonların durumları (idle → recording → finished) bir state machine ile yönetilmeli. Basit bir enum + JavaScript state yönetimi karmaşıklığı azaltır.

1.3 TR-ENG Content (Çok dilli destek)

Detay: Arayüz metinleri Türkçe ve İngilizce olarak sunulacak.

Olası Pürüz	Açıklama	Çözüm Önerisi
Hardcoded stringler	Metinler template'lere gömülürse dil ekleme zorlaşır	Django `i18n` framework'ü kullan: `{% trans %}` tag'leri + `.po` dosyaları
Dil değiştirme UX	Dil değiştiğinde sayfa yenilenmesi gerekir	`django.middleware.locale.LocaleMiddleware` + URL prefix (`/tr/`, `/en/`) veya session-based dil tercihi
Mülakat soruları dili	Sorular DB'de ise her sorunun iki dil versiyonu lazım	Sorular tablosunda `question_tr` + `question_en` alanları veya ayrı `Translation` tablosu

[!TIP] Avantajlı Alternatif: Eğer sadece 2 dil olacaksa (TR/EN), Django i18n yerine basit bir JSON-based dictionary yaklaşımı da yeterli olabilir — daha az overhead, daha hızlı geliştirme. Ama ileride 3+ dil planlıyorsanız i18n tercih edin.

1.4 Dummy Mülakat Soruları

Detay: Geliştirme/demo aşamasında kullanılacak sabit soru seti.

Olası Pürüz	Açıklama	Çözüm Önerisi
Sorular nerede tutulacak?	Kod içinde mi, DB'de mi, JSON dosyasında mı?	Öneri: DB'de tutun (`Question` modeli). Fixture/seed script ile dummy dataları yükleyin (`python manage.py loaddata`). İleride gerçek sorularla değiştirmek sorunsuz olur
Soru sıralaması	Herkese aynı sırada mı, rastgele mi?	Şimdilik sıralı, ama modelde `order` alanı bırakın. İleride `random` veya `adaptive` gibi stratejiler eklenebilir
Soru tipi çeşitliliği	Sadece metin mi, yoksa seçenekli/video sorular da olacak mı?	Şimdilik sadece metin. Ama modele `question_type` (text, multiple_choice, video) alanı ekleyin — bozmaz, genişletir

1.5 WebRTC — Gerçek Zamanlı Video Akışı

Detay: Kullanıcının kamerasından alınan video akışını WebRTC ile sunucuya (veya doğrudan model servisine) gerçek zamanlı iletmek. Bu sayede frame'ler anlık olarak emotion inference'a gönderilebilir ve video kaydı sunucu tarafında yapılabilir.

Akış:

Browser (getUserMedia) → WebRTC PeerConnection → Signaling (Django Channels) → Media Server → Model Service

Olası Pürüz	Açıklama	Çözüm Önerisi
Signaling sunucusu	WebRTC bağlantısı kurmak için SDP/ICE mesaj alışverişi gerekir	Django Channels (WebSocket) ile signaling endpoint'i oluşturun. `ws://host/ws/signaling/<session_id>/`
NAT traversal	Kullanıcı NAT/firewall arkasındaysa doğrudan bağlantı kurulamaz	STUN sunucusu (ücretsiz: Google STUN `stun:stun.l.google.com:19302`) + gerektiğinde TURN sunucusu (self-hosted: `coturn`)
TURN sunucusu maliyeti	TURN relay trafiği bant genişliği tüketir	Önce STUN ile dene, sadece STUN başarısız olursa TURN'e düş. Geliştirmede localhost'ta TURN gerekmez
Media server ihtiyacı	WebRTC peer-to-peer'dır, sunucunun videoyu alması için bir media endpoint lazım	Basit yol: `aiortc` (Python WebRTC kütüphanesi) ile sunucu tarafında peer oluşturun. Gelişmiş yol: Janus/mediasoup gibi bir SFU kullanın
Tarayıcı uyumluluğu	Bazı eski tarayıcılar WebRTC desteklemez	`adapter.js` shim kütüphanesini ekleyin. Modern tarayıcılarda (Chrome, Firefox, Edge, Safari 11+) sorun yok
Ses vs sadece video	Mülakatda ses de kaydedilecek mi?	`getUserMedia({ video: true, audio: true })` ile hem video hem ses alın. WebRTC her ikisini de aynı PeerConnection üzerinden taşır

[!IMPORTANT] WebRTC vs MediaRecorder Karşılaştırması:

WebRTC MediaRecorder (mevcut plan)

Real-time streaming ✅ Sunucuya anlık akış ❌ Sadece client-side kayıt

Sunucu tarafı kayıt ✅ Media server ile ❌ Upload gerekli

Real-time inference ✅ Frame'ler anında sunucuya ⚠️ Batch POST gerekli

Karmaşıklık Yüksek (signaling, ICE, TURN) Düşük

Bant genişliği Sürekli stream Sadece upload anında

Öneri: İkisini birlikte kullanın — WebRTC real-time emotion inference için frame stream'i, MediaRecorder yedek video kaydı (client-side, WebRTC kesilirse kayıp olmaz).

	WebRTC	MediaRecorder (mevcut plan)
Real-time streaming	✅ Sunucuya anlık akış	❌ Sadece client-side kayıt
Sunucu tarafı kayıt	✅ Media server ile	❌ Upload gerekli
Real-time inference	✅ Frame'ler anında sunucuya	⚠️ Batch POST gerekli
Karmaşıklık	Yüksek (signaling, ICE, TURN)	Düşük
Bant genişliği	Sürekli stream	Sadece upload anında

[!TIP] aiortc ile Basit Entegrasyon: Python'da WebRTC peer oluşturmak için aiortc kütüphanesi idealdir. Django Channels ile aynı async event loop üzerinde çalışır. Video frame'lerini doğrudan VideoStreamTrack üzerinden alıp model servisine iletebilirsiniz.

2. Arka Yüz (Backend)

2.1 User-Login (kod ile)

Detay: Frontend ile aynı auth sistemi. Django auth backend, session management.

Olası Pürüz	Açıklama	Çözüm Önerisi
API vs Template-based auth	Kamera erişimi JS gerektirdiğinden, sayfalar ne kadar SPA olacak?	İki yol: (A) Klasik Django template + AJAX çağrıları (basit), (B) DRF + JWT ile tam API (esnek ama karmaşık). Öneri: Şu an için (A) yeterli
User modeli genişletme	İleride kullanıcıya özel alanlar lazım olabilir (departman, pozisyon vb.)	`AbstractUser`'dan miras alan custom User modeli şimdiden oluşturun — sonradan değiştirmek çok zor
Admin paneli	Sorular ve session'lar yönetilmeli	Django Admin'e `Question`, `InterviewSession`, `EmotionRecord` modellerini kaydedin

[!CAUTION] Kritik: Django projesi başlarken AUTH_USER_MODEL ayarını custom user modeline yönlendirin. Sonradan değiştirmek migration cehennemine yol açar.

2.2 User + Session Based Duygu Kayıtları

Format: [timestamp, "mutlu":0.2, "üzgün":0.6, ...] + video kaydı

Olası Pürüz	Açıklama	Çözüm Önerisi
Yüksek frekanslı veri yazma	Her frame'de DB'ye yazarsanız performans düşer	WebRTC ile gelen frame'leri sunucu tarafında buffer'layın (Redis/in-memory queue) → periyodik DB flush
Video kayıt — çift katman	Hem sunucu hem client tarafında kayıt stratejisi	WebRTC stream: `aiortc` ile sunucu tarafında kayıt (birincil). MediaRecorder: Client-side yedek kayıt (fallback). Format: WebM (VP9)
Video saklama	Dosya sistemi mi, object storage mı?	Geliştirme: `MEDIA_ROOT` ile local. Prodüksiyon: S3/MinIO. Django `FileField` her ikisini de destekler
Veri modeli tasarımı	Emotion verileri nasıl saklanmalı?	Önerilen model yapısı aşağıda
Zaman senkronizasyonu	Video timestamp ile emotion timestamp uyuşmazlığı	WebRTC RTP timestamp'larını kullanın — frame ve emotion timestamp'ları doğal olarak senkron olur
Django Channels altyapısı	WebRTC signaling ve WebSocket için ASGI gerekir	`daphne` veya `uvicorn` ASGI server kullanın. `ASGI_APPLICATION` ayarını yapılandırın

Önerilen DB Modeli:

class InterviewSession(models.Model):
    user = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE)
    started_at = models.DateTimeField(auto_now_add=True)
    ended_at = models.DateTimeField(null=True, blank=True)
    video_file = models.FileField(upload_to='interviews/videos/', null=True)
    language = models.CharField(max_length=2, choices=[('tr','TR'),('en','EN')])
    status = models.CharField(max_length=20, default='in_progress')  # in_progress, completed, abandoned

class EmotionRecord(models.Model):
    session = models.ForeignKey(InterviewSession, on_delete=models.CASCADE, related_name='emotions')
    timestamp = models.FloatField()  # saniye cinsinden, session başlangıcına göre
    happy = models.FloatField(default=0)
    sad = models.FloatField(default=0)
    angry = models.FloatField(default=0)
    surprised = models.FloatField(default=0)
    fearful = models.FloatField(default=0)
    disgusted = models.FloatField(default=0)
    neutral = models.FloatField(default=0)
    # Alternatif: emotions = models.JSONField()  → daha esnek ama sorgulaması zor

[!NOTE] Trade-off: JSONField ile emotion'ları tek alanda tutmak esnektir ama SQL ile filtreleme/aggregation zorlaşır. Ayrı float alanları query dostu ama model değişikliği gerektirir. Öneri: Emotion sayısı sabit kalacaksa ayrı alanlar; değişecekse JSONField.

3. Perception (Model Katmanı)

3.1 Model Doğruluğu Artırılması

Olası Pürüz	Açıklama	Çözüm Önerisi
Model-Django entegrasyonu	PyTorch/TF modeli Django process'inde çalıştırmak bellek sorunlarına yol açar	Öneri: Modeli ayrı bir microservice olarak çalıştırın (FastAPI + model server). `aiortc` → frame alır → model servisine iletir
GPU vs CPU inference	Sunucuda GPU yoksa inference yavaş olur	ONNX Runtime ile CPU optimizasyonu veya TensorRT ile GPU hızlandırma. Client-side inference (TF.js/ONNX.js) alternatif ama model boyutuna bağlı
Model güncelleme	Yeni model eğitildiğinde deployment nasıl olacak?	Model dosyasını versiyonlayın (`model_v1.onnx`, `model_v2.onnx`). Config ile hangi versiyonun aktif olduğunu belirleyin
Real-time vs batch inference	Her frame'i anında mı analiz edeceksiniz?	WebRTC ile gelen frame'lerden her 2-3 FPS'te birini model'e gönderin. `aiortc` `VideoStreamTrack` üzerinde frame skip mantığı uygulayın

[!TIP] Avantajlı Alternatif — Client-Side Inference: Eğer model yeterince küçükse (~5-20MB), TensorFlow.js veya ONNX.js ile emotion detection'ı doğrudan tarayıcıda çalıştırabilirsiniz. Avantajları: - Sunucu yükü sıfır - Latency çok düşük - Video verisi sunucuya gönderilmeden işlenir (gizlilik)

Dezavantaj: Düşük donanımlı client'larda performans sorunu.

3.2 Time-Based Solution'ların Tekrardan Eklenmesi

Olası Pürüz	Açıklama	Çözüm Önerisi
Temporal smoothing	Anlık tahminler gürültülü olur (frame'den frame'e zıplama)	Sliding window averaging (son 5-10 frame'in ortalaması) veya exponential moving average (EMA)
Temporal model entegrasyonu	LSTM/Transformer gibi modeller session-level state tutar	Session başına bir model state tutulmalı — memory management önemli. Her session kapanınca state temizlenmeli
Senkronizasyon	Time-based prediction'lar ile soru geçişleri eşleşmeli	Her soru geçişinde bir "marker" timestamp kaydedin → analiz aşamasında soru bazlı emotion grafiği çıkarılabilir

4. Genel Mimari Önerileri

┌─────────────────────────────────────────────────────────────┐
│                      BROWSER (Client)                       │
│  ┌──────────┐  ┌──────────┐  ┌─────────────────────────┐   │
│  │  Login   │  │ Mülakat  │  │  getUserMedia            │   │
│  │  Formu   │  │ UI/Sorular│ │  + RTCPeerConnection    │   │
│  └────┬─────┘  └────┬─────┘  │  + MediaRecorder (yedek)│   │
│       │              │        └────────┬────────────────┘   │
│       │              │                 │                    │
│       │              │         WebRTC Media Stream           │
│       │              │         + Signaling (WebSocket)       │
└───────┼──────────────┼─────────────────┼────────────────────┘
        │              │                 │
        ▼              ▼                 ▼
┌─────────────────────────────────────────────────────────────┐
│              DJANGO BACKEND (ASGI — Daphne/Uvicorn)         │
│  ┌─────────┐  ┌────────────┐  ┌──────────────────────────┐  │
│  │  Auth   │  │  Session   │  │  Django Channels         │  │
│  │  Views  │  │  Manager   │  │  (WebSocket Signaling)   │  │
│  └─────────┘  └──────┬─────┘  └────────────┬─────────────┘  │
│                      │                     │                │
│               ┌──────▼──────┐    ┌─────────▼────────────┐   │
│               │  PostgreSQL │    │  aiortc (Python peer) │  │
│               │  (DB)       │    │  Video frame alımı    │  │
│               └─────────────┘    └─────────┬────────────┘   │
│                                            │                │
│                               ┌────────────▼────────────┐   │
│                               │  STUN/TURN (coturn)     │   │
│                               │  NAT traversal          │   │
│                               └─────────────────────────┘   │
└────────────────────────────────────────┬────────────────────┘
                                         │ Frame → HTTP/gRPC
                                         ▼
                               ┌────────────────────┐
                               │  Model Service     │
                               │  (FastAPI)         │
                               │  Emotion Inference │
                               └────────────────────┘

[!WARNING] SQLite vs PostgreSQL: Django varsayılan olarak SQLite kullanır. Geliştirme için yeterli ama concurrent write sorunları yaşatır. Eğer birden fazla kullanıcı aynı anda mülakat yapacaksa PostgreSQL kullanın. Proje başından itibaren PostgreSQL ayarlarsanız migration sorunları yaşamazsınız.

5. Öncelik Sıralaması Önerisi

Sıra	İş	Neden?
1	Custom User Model + DB setup (PostgreSQL)	Sonradan değiştirmek çok zor
2	Login ekranı (frontend + backend)	Temel altyapı
3	Django Channels + ASGI kurulumu	WebRTC signaling altyapısı, erken kurulmalı
4	Question modeli + dummy data fixture	Mülakatın iskeletini oluşturur
5	Mülakat sayfası + başlat/bitir butonları	Akışın çekirdeği
6	WebRTC entegrasyonu (signaling + `aiortc` peer)	Real-time video akışı
7	Kamera erişimi + MediaRecorder (yedek kayıt)	Fallback video kaydı
8	Session + EmotionRecord modelleri	Backend veri katmanı
9	Model servisi entegrasyonu	Perception katmanı
10	Time-based smoothing	Model kalitesi
11	TR/EN çoklu dil desteği	Polish aşaması

6. WebRTC Gerekli Paketler Özeti

Paket	Amaç	Kurulum
`channels`	Django WebSocket/ASGI desteği	`pip install channels`
`channels-redis`	Channel layer backend (prod)	`pip install channels-redis`
`daphne`	ASGI HTTP/WebSocket server	`pip install daphne`
`aiortc`	Python tarafında WebRTC peer	`pip install aiortc`
`adapter.js`	Tarayıcı WebRTC uyumluluk shim	CDN veya npm
`coturn`	TURN/STUN sunucusu (prod)	System package / Docker

EK

def add_data_to_session(request, session_id, conf_array):
    session = Session.objects.get(id=session_id)

    # 🔥 kritik kontrol
    if session.user != request.user:
        raise Exception("Bu session sana ait değil")

    data = Data.objects.create(
        session=session,
        timestamp=timezone.now(),
        conf=conf_array
    )

return data