website/models.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-

from flask_sqlalchemy import SQLAlchemy
from flask_login import UserMixin
from datetime import datetime
from werkzeug.security import generate_password_hash, check_password_hash
from enum import Enum
import uuid as uuid_pkg
import os

db = SQLAlchemy()

# Beziehungstypen für Gedankenverknüpfungen
class RelationType(Enum):
    SUPPORTS = "stützt"
    CONTRADICTS = "widerspricht"
    BUILDS_UPON = "baut auf auf"
    GENERALIZES = "verallgemeinert"
    SPECIFIES = "spezifiziert"
    INSPIRES = "inspiriert"

# Beziehungstabelle für viele-zu-viele Beziehung zwischen MindMapNodes
node_relationship = db.Table('node_relationship',
    db.Column('parent_id', db.Integer, db.ForeignKey('mind_map_node.id'), primary_key=True),
    db.Column('child_id', db.Integer, db.ForeignKey('mind_map_node.id'), primary_key=True)
)

# Beziehungstabelle für öffentliche Knoten und Gedanken
node_thought_association = db.Table('node_thought_association',
    db.Column('node_id', db.Integer, db.ForeignKey('mind_map_node.id'), primary_key=True),
    db.Column('thought_id', db.Integer, db.ForeignKey('thought.id'), primary_key=True)
)

# Beziehungstabelle für Benutzer-spezifische Mindmap-Knoten und Gedanken
user_mindmap_thought_association = db.Table('user_mindmap_thought_association',
    db.Column('user_mindmap_id', db.Integer, db.ForeignKey('user_mindmap.id'), primary_key=True),
    db.Column('thought_id', db.Integer, db.ForeignKey('thought.id'), primary_key=True)
)

# Beziehungstabelle für Benutzer-Bookmarks von Gedanken
user_thought_bookmark = db.Table('user_thought_bookmark',
    db.Column('user_id', db.Integer, db.ForeignKey('user.id'), primary_key=True),
    db.Column('thought_id', db.Integer, db.ForeignKey('thought.id'), primary_key=True),
    db.Column('created_at', db.DateTime, default=datetime.utcnow)
)

class User(db.Model, UserMixin):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password = db.Column(db.String(512), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    is_active = db.Column(db.Boolean, default=True)
    role = db.Column(db.String(20), default="user")  # 'user', 'admin', 'moderator'
    bio = db.Column(db.Text, nullable=True)  # Profil-Bio
    location = db.Column(db.String(100), nullable=True)  # Standort
    website = db.Column(db.String(200), nullable=True)  # Website
    avatar = db.Column(db.String(200), nullable=True)  # Profilbild-URL
    last_login = db.Column(db.DateTime, nullable=True)  # Letzter Login
    
    # Relationships
    threads = db.relationship('Thread', backref='creator', lazy=True)
    messages = db.relationship('Message', backref='author', lazy=True)
    projects = db.relationship('Project', backref='owner', lazy=True)
    mindmaps = db.relationship('UserMindmap', backref='user', lazy=True)
    thoughts = db.relationship('Thought', backref='author', lazy=True)
    bookmarked_thoughts = db.relationship('Thought', secondary=user_thought_bookmark, 
                                        lazy='dynamic', backref=db.backref('bookmarked_by', lazy='dynamic'))
    
    def __repr__(self):
        return f'<User {self.username}>'

    def set_password(self, password):
        self.password = generate_password_hash(password)
        
    def check_password(self, password):
        return check_password_hash(self.password, password)
        
    @property
    def is_admin(self):
        return self.role == 'admin'

    @is_admin.setter
    def is_admin(self, value):
        self.role = 'admin' if value else 'user'

class Category(db.Model):
    """Wissenschaftliche Kategorien für die Gliederung der öffentlichen Mindmap"""
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), unique=True, nullable=False)
    description = db.Column(db.Text)
    color_code = db.Column(db.String(7))  # Hex color
    icon = db.Column(db.String(50))
    parent_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=True)
    
    # Beziehungen
    children = db.relationship('Category', backref=db.backref('parent', remote_side=[id]))
    nodes = db.relationship('MindMapNode', backref='category', lazy=True)

    def __repr__(self):
        return f'<Category {self.name}>'

class MindMapNode(db.Model):
    """Öffentliche Mindmap-Knoten, die für alle Benutzer sichtbar sind"""
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    description = db.Column(db.Text)
    color_code = db.Column(db.String(7))
    icon = db.Column(db.String(50))
    is_public = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    created_by_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
    category_id = db.Column(db.Integer, db.ForeignKey('category.id'), nullable=True)

    __table_args__ = {'extend_existing': True}

    # Beziehungen für Baumstruktur (mehrere Eltern möglich)
    parents = db.relationship(
        'MindMapNode', 
        secondary=node_relationship,
        primaryjoin=(node_relationship.c.child_id == id),
        secondaryjoin=(node_relationship.c.parent_id == id),
        backref=db.backref('children', lazy='dynamic'),
        lazy='dynamic'
    )
    
    # Beziehungen zu Gedanken
    thoughts = db.relationship('Thought', 
                              secondary=node_thought_association,
                              backref=db.backref('nodes', lazy='dynamic'))
    
    # Beziehung zum Ersteller
    created_by = db.relationship('User', backref='created_nodes')

    def __repr__(self):
        return f'<MindMapNode {self.name}>'
    
    def to_dict(self):
        return {
            'id': self.id,
            'name': self.name,
            'description': self.description,
            'color_code': self.color_code,
            'icon': self.icon,
            'category_id': self.category_id,
            'created_at': self.created_at.isoformat() if self.created_at else None
        }

class UserMindmap(db.Model):
    """Benutzerspezifische Mindmap, die vom Benutzer personalisierbar ist"""
    id = db.Column(db.Integer, primary_key=True)
    name = db.Column(db.String(100), nullable=False)
    description = db.Column(db.Text)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_modified = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    is_private = db.Column(db.Boolean, default=True)
    
    # Beziehungen zu öffentlichen Knoten
    public_nodes = db.relationship('MindMapNode', 
                                  secondary='user_mindmap_node',
                                  backref=db.backref('in_user_mindmaps', lazy='dynamic'))
    
    # Beziehungen zu Gedanken
    thoughts = db.relationship('Thought', 
                              secondary=user_mindmap_thought_association,
                              backref=db.backref('in_user_mindmaps', lazy='dynamic'))
    
    # Notizen zu dieser Mindmap
    notes = db.relationship('MindmapNote', backref='mindmap', lazy=True)

# Beziehungstabelle für benutzerorientierte Mindmaps und öffentliche Knoten
class UserMindmapNode(db.Model):
    """Speichert die Beziehung zwischen Benutzer-Mindmaps und öffentlichen Knoten inkl. Position"""
    user_mindmap_id = db.Column(db.Integer, db.ForeignKey('user_mindmap.id'), primary_key=True)
    node_id = db.Column(db.Integer, db.ForeignKey('mind_map_node.id'), primary_key=True)
    x_position = db.Column(db.Float, default=0)  # Position X auf der Mindmap
    y_position = db.Column(db.Float, default=0)  # Position Y auf der Mindmap
    scale = db.Column(db.Float, default=1.0)     # Größe des Knotens
    added_at = db.Column(db.DateTime, default=datetime.utcnow)

class MindmapNote(db.Model):
    """Private Notizen der Benutzer zu ihrer Mindmap"""
    id = db.Column(db.Integer, primary_key=True)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    mindmap_id = db.Column(db.Integer, db.ForeignKey('user_mindmap.id'), nullable=False)
    node_id = db.Column(db.Integer, db.ForeignKey('mind_map_node.id'), nullable=True)
    thought_id = db.Column(db.Integer, db.ForeignKey('thought.id'), nullable=True)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_modified = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    color_code = db.Column(db.String(7), default="#FFF59D")  # Farbe der Notiz

class Thought(db.Model):
    """Gedanken und Inhalte, die in der Mindmap verknüpft werden können"""
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)
    abstract = db.Column(db.Text)
    keywords = db.Column(db.String(500))
    color_code = db.Column(db.String(7))  # Hex color code
    source_type = db.Column(db.String(50))  # PDF, Markdown, Text etc.
    branch = db.Column(db.String(100), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_modified = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    
    # Beziehungen
    comments = db.relationship('Comment', backref='thought', lazy=True, cascade="all, delete-orphan")
    ratings = db.relationship('ThoughtRating', backref='thought', lazy=True)
    
    outgoing_relations = db.relationship(
        'ThoughtRelation',
        foreign_keys='ThoughtRelation.source_id',
        backref='source_thought',
        lazy=True
    )
    incoming_relations = db.relationship(
        'ThoughtRelation',
        foreign_keys='ThoughtRelation.target_id',
        backref='target_thought',
        lazy=True
    )
    
    @property
    def average_rating(self):
        if not self.ratings:
            return 0
        return sum(r.relevance_score for r in self.ratings) / len(self.ratings)

class ThoughtRelation(db.Model):
    """Beziehungen zwischen Gedanken"""
    id = db.Column(db.Integer, primary_key=True)
    source_id = db.Column(db.Integer, db.ForeignKey('thought.id'), nullable=False)
    target_id = db.Column(db.Integer, db.ForeignKey('thought.id'), nullable=False)
    relation_type = db.Column(db.Enum(RelationType), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    created_by_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    
    # Beziehung zum Ersteller
    created_by = db.relationship('User', backref='created_relations')

class ThoughtRating(db.Model):
    """Bewertungen von Gedanken durch Benutzer"""
    id = db.Column(db.Integer, primary_key=True)
    thought_id = db.Column(db.Integer, db.ForeignKey('thought.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    relevance_score = db.Column(db.Integer, nullable=False)  # 1-5
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    
    __table_args__ = (
        db.UniqueConstraint('thought_id', 'user_id', name='unique_thought_rating'),
    )
    
    # Beziehung zum Benutzer
    user = db.relationship('User', backref='ratings')

class Comment(db.Model):
    """Kommentare zu Gedanken"""
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    thought_id = db.Column(db.Integer, db.ForeignKey('thought.id'), nullable=False)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_modified = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow) 

# Thread model
class Thread(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    description = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    
    # Relationships
    messages = db.relationship('Message', backref='thread', lazy=True, cascade="all, delete-orphan")
    
    def __repr__(self):
        return f'<Thread {self.title}>'

# Message model
class Message(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    thread_id = db.Column(db.Integer, db.ForeignKey('thread.id'), nullable=False)
    role = db.Column(db.String(20), default="user")  # 'user', 'assistant', 'system'
    
    def __repr__(self):
        return f'<Message {self.id} by {self.user_id}>'

# Project model
class Project(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(150), nullable=False)
    description = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
    
    # Relationships
    documents = db.relationship('Document', backref='project', lazy=True, cascade="all, delete-orphan")
    
    def __repr__(self):
        return f'<Project {self.title}>'

# Document model
class Document(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(150), nullable=False)
    content = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    project_id = db.Column(db.Integer, db.ForeignKey('project.id'), nullable=False)
    filename = db.Column(db.String(150), nullable=True)
    file_path = db.Column(db.String(300), nullable=True)
    file_type = db.Column(db.String(50), nullable=True)
    file_size = db.Column(db.Integer, nullable=True)
    
    def __repr__(self):
        return f'<Document {self.title}>'

# Forum-Kategorie-Modell - entspricht den Hauptknotenpunkten der Mindmap
class ForumCategory(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    node_id = db.Column(db.Integer, db.ForeignKey('mind_map_node.id'), nullable=False)
    title = db.Column(db.String(200), nullable=False)
    description = db.Column(db.Text)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    is_active = db.Column(db.Boolean, default=True)
    
    # Beziehungen
    node = db.relationship('MindMapNode', backref='forum_category')
    posts = db.relationship('ForumPost', backref='category', lazy=True, cascade="all, delete-orphan")
    
    def __repr__(self):
        return f'<ForumCategory {self.title}>'

# Forum-Beitrag-Modell
class ForumPost(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    title = db.Column(db.String(200), nullable=False)
    content = db.Column(db.Text, nullable=False)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    category_id = db.Column(db.Integer, db.ForeignKey('forum_category.id'), nullable=False)
    parent_id = db.Column(db.Integer, db.ForeignKey('forum_post.id'), nullable=True)
    is_pinned = db.Column(db.Boolean, default=False)
    is_locked = db.Column(db.Boolean, default=False)
    view_count = db.Column(db.Integer, default=0)
    
    # Beziehungen
    author = db.relationship('User', backref='forum_posts')
    replies = db.relationship('ForumPost', backref=db.backref('parent', remote_side=[id]), lazy=True)
    
    def __repr__(self):
        return f'<ForumPost {self.title}>'

# Berechtigungstypen für Mindmap-Freigaben
class PermissionType(Enum):
    READ = "Nur-Lesen"
    EDIT = "Bearbeiten"
    ADMIN = "Administrator"

# Freigabemodell für Mindmaps
class MindmapShare(db.Model):
    """Speichert Informationen über freigegebene Mindmaps und Berechtigungen"""
    id = db.Column(db.Integer, primary_key=True)
    mindmap_id = db.Column(db.Integer, db.ForeignKey('user_mindmap.id'), nullable=False)
    shared_by_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    shared_with_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
    permission_type = db.Column(db.Enum(PermissionType), nullable=False, default=PermissionType.READ)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)
    last_accessed = db.Column(db.DateTime, nullable=True)
    
    # Beziehungen
    mindmap = db.relationship('UserMindmap', backref=db.backref('shares', lazy='dynamic'))
    shared_by = db.relationship('User', foreign_keys=[shared_by_id], backref=db.backref('shared_mindmaps', lazy='dynamic'))
    shared_with = db.relationship('User', foreign_keys=[shared_with_id], backref=db.backref('accessible_mindmaps', lazy='dynamic'))
    
    __table_args__ = (
        db.UniqueConstraint('mindmap_id', 'shared_with_id', name='unique_mindmap_share'),
    )
    
    def __repr__(self):
        return f'<MindmapShare: {self.mindmap_id} - {self.shared_with_id} - {self.permission_type.name}>'