updated first commit

app/models/__init__.py

@@ -0,0 +1,11 @@
+"""
+Database models package
+"""
+
+from .user import User
+from .player import Player
+from .content import Content
+from .group import Group, group_player
+from .server_log import ServerLog
+
+__all__ = ['User', 'Player', 'Content', 'Group', 'ServerLog', 'group_player']

app/models/content.py

@@ -0,0 +1,38 @@
+"""
+Content model for media files
+"""
+
+from app.extensions import db
+
+class Content(db.Model):
+    """Content model representing media files for players"""
+    
+    id = db.Column(db.Integer, primary_key=True)
+    file_name = db.Column(db.String(255), nullable=False, index=True)
+    original_name = db.Column(db.String(255), nullable=True)
+    duration = db.Column(db.Integer, nullable=False, default=10)  # Duration in seconds
+    position = db.Column(db.Integer, default=0)  # Position in playlist
+    player_id = db.Column(db.Integer, db.ForeignKey('player.id'), nullable=False, index=True)
+    content_type = db.Column(db.String(50), nullable=False, default='image')  # image, video, document
+    file_size = db.Column(db.Integer, nullable=True)  # File size in bytes
+    uploaded_at = db.Column(db.DateTime, default=db.func.current_timestamp())
+    is_active = db.Column(db.Boolean, default=True)
+    
+    # Metadata for different content types
+    width = db.Column(db.Integer, nullable=True)
+    height = db.Column(db.Integer, nullable=True)
+    format = db.Column(db.String(10), nullable=True)
+
+    @property
+    def file_path(self):
+        """Get the full file path for this content"""
+        return f"uploads/{self.file_name}"
+
+    @property
+    def url(self):
+        """Get the URL for this content"""
+        from flask import url_for
+        return url_for('static', filename=self.file_path)
+
+    def __repr__(self):
+        return f'<Content {self.file_name} (Player: {self.player_id})>'

app/models/group.py

@@ -0,0 +1,48 @@
+"""
+Group model for managing collections of players
+"""
+
+from app.extensions import db
+
+# Association table for many-to-many relationship between Group and Player
+group_player = db.Table('group_player',
+    db.Column('group_id', db.Integer, db.ForeignKey('group.id'), primary_key=True),
+    db.Column('player_id', db.Integer, db.ForeignKey('player.id'), primary_key=True)
+)
+
+class Group(db.Model):
+    """Group model for managing collections of players"""
+    
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(100), nullable=False, unique=True, index=True)
+    description = db.Column(db.Text, nullable=True)
+    playlist_version = db.Column(db.Integer, default=0)
+    created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
+    is_active = db.Column(db.Boolean, default=True)
+    
+    # Relationships
+    players = db.relationship('Player', secondary=group_player, backref='groups')
+
+    def increment_playlist_version(self):
+        """Increment playlist version for all players in group"""
+        self.playlist_version += 1
+        for player in self.players:
+            player.increment_playlist_version()
+        db.session.commit()
+
+    @property
+    def player_count(self):
+        """Get the number of players in this group"""
+        return len(self.players)
+
+    def get_content(self):
+        """Get all content from players in this group"""
+        from app.models.content import Content
+        if not self.players:
+            return []
+        
+        player_ids = [player.id for player in self.players]
+        return Content.query.filter(Content.player_id.in_(player_ids)).order_by(Content.position).all()
+
+    def __repr__(self):
+        return f'<Group {self.name} ({self.player_count} players)>'

app/models/player.py

@@ -0,0 +1,54 @@
+"""
+Player model for digital signage displays
+"""
+
+from app.extensions import db, bcrypt
+
+class Player(db.Model):
+    """Player model representing digital signage displays"""
+    
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(255), nullable=False, index=True)
+    hostname = db.Column(db.String(255), nullable=False, unique=True, index=True)
+    password = db.Column(db.String(255), nullable=False)
+    quickconnect_password = db.Column(db.String(255), nullable=True)
+    playlist_version = db.Column(db.Integer, default=1)
+    locked_to_group_id = db.Column(db.Integer, db.ForeignKey('group.id'), nullable=True)
+    created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
+    last_seen = db.Column(db.DateTime)
+    is_active = db.Column(db.Boolean, default=True)
+    
+    # Relationships
+    content = db.relationship('Content', backref='player', lazy=True, cascade='all, delete-orphan')
+    locked_to_group = db.relationship('Group', foreign_keys=[locked_to_group_id], backref='locked_players')
+
+    def set_password(self, password):
+        """Hash and set player password"""
+        self.password = bcrypt.generate_password_hash(password).decode('utf-8')
+
+    def check_password(self, password):
+        """Check if provided password matches player's password"""
+        return bcrypt.check_password_hash(self.password, password)
+
+    def set_quickconnect_password(self, password):
+        """Hash and set quickconnect password"""
+        self.quickconnect_password = bcrypt.generate_password_hash(password).decode('utf-8')
+
+    def verify_quickconnect_code(self, code):
+        """Verify quickconnect code"""
+        if not self.quickconnect_password:
+            return False
+        return bcrypt.check_password_hash(self.quickconnect_password, code)
+
+    def increment_playlist_version(self):
+        """Increment playlist version to notify clients of changes"""
+        self.playlist_version += 1
+        db.session.commit()
+
+    @property
+    def is_locked_to_group(self):
+        """Check if player is locked to a group"""
+        return self.locked_to_group_id is not None
+
+    def __repr__(self):
+        return f'<Player {self.username} ({self.hostname})>'

app/models/server_log.py

@@ -0,0 +1,42 @@
+"""
+Server log model for audit trail
+"""
+
+from app.extensions import db
+import datetime
+
+class ServerLog(db.Model):
+    """Server log model for tracking system actions"""
+    
+    id = db.Column(db.Integer, primary_key=True)
+    action = db.Column(db.String(255), nullable=False, index=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=True)
+    ip_address = db.Column(db.String(45), nullable=True)  # Support IPv6
+    user_agent = db.Column(db.Text, nullable=True)
+    timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow, index=True)
+    level = db.Column(db.String(20), default='INFO')  # INFO, WARNING, ERROR, DEBUG
+    
+    # Relationships
+    user = db.relationship('User', backref='logs')
+
+    @staticmethod
+    def log(action, user_id=None, ip_address=None, user_agent=None, level='INFO'):
+        """Create a new log entry"""
+        log_entry = ServerLog(
+            action=action,
+            user_id=user_id,
+            ip_address=ip_address,
+            user_agent=user_agent,
+            level=level
+        )
+        db.session.add(log_entry)
+        db.session.commit()
+        return log_entry
+
+    @staticmethod
+    def get_recent_logs(limit=50):
+        """Get recent log entries"""
+        return ServerLog.query.order_by(ServerLog.timestamp.desc()).limit(limit).all()
+
+    def __repr__(self):
+        return f'<ServerLog {self.action} at {self.timestamp}>'

app/models/user.py

@@ -0,0 +1,53 @@
+"""
+User model for authentication and authorization
+"""
+
+from flask_login import UserMixin
+from app.extensions import db, bcrypt
+
+class User(db.Model, UserMixin):
+    """User model for authentication and role management"""
+    
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(80), unique=True, nullable=False, index=True)
+    password = db.Column(db.String(255), nullable=False)
+    role = db.Column(db.String(80), nullable=False, default='user')
+    theme = db.Column(db.String(80), default='light')
+    created_at = db.Column(db.DateTime, default=db.func.current_timestamp())
+    last_login = db.Column(db.DateTime)
+    is_active_user = db.Column(db.Boolean, default=True)
+
+    def set_password(self, password):
+        """Hash and set user password"""
+        self.password = bcrypt.generate_password_hash(password).decode('utf-8')
+
+    def check_password(self, password):
+        """Check if provided password matches user's password"""
+        return bcrypt.check_password_hash(self.password, password)
+
+    @property
+    def is_admin(self):
+        """Check if user has admin role"""
+        return self.role == 'admin'
+
+    @property
+    def is_active(self):
+        """Required by Flask-Login"""
+        return self.is_active_user
+
+    @property
+    def is_authenticated(self):
+        """Required by Flask-Login"""
+        return True
+
+    @property
+    def is_anonymous(self):
+        """Required by Flask-Login"""
+        return False
+
+    def get_id(self):
+        """Required by Flask-Login"""
+        return str(self.id)
+
+    def __repr__(self):
+        return f'<User {self.username}>'