ske087/moto-adv-website
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
1661f5f588c16ec1393b6711aa591a0b95108300
moto-adv-website/app/models.py
ske087 1661f5f588 feat: Complete chat system implementation and password reset enhancement 
- Add comprehensive chat system with modern UI design
- Implement admin-based password reset system
- Fix template syntax errors and 500 server errors
- Add chat routes, API endpoints, and database models
- Enhance user interface with Tailwind CSS card-based design
- Implement community guidelines and quick action features
- Add responsive design for mobile and desktop compatibility
- Create support chat functionality with admin integration
- Fix JavaScript inheritance in base template
- Add database migration for chat system tables

Features:
✅ Modern chat interface with room management
✅ Admin-based password reset workflow
✅ Real-time chat with mobile app support
✅ Professional UI with gradient cards and hover effects
✅ Community guidelines and safety features
✅ Responsive design for all devices
✅ Error-free template rendering
2025-08-09 20:44:25 +03:00

439 lines
18 KiB
Python
Raw Blame History

from datetime import datetime
import os
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from app.extensions import db
class User(UserMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.Integer, primary_key=True)
nickname = db.Column(db.String(80), unique=True, nullable=False)
email = db.Column(db.String(120), unique=True, nullable=False)
password_hash = db.Column(db.String(255), nullable=False)
is_active = db.Column(db.Boolean, default=True, nullable=False)
is_admin = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Relationships
posts = db.relationship('Post', backref='author', lazy='dynamic', cascade='all, delete-orphan')
comments = db.relationship('Comment', backref='author', lazy='dynamic', cascade='all, delete-orphan')
likes = db.relationship('Like', backref='user', lazy='dynamic', cascade='all, delete-orphan')
def set_password(self, password):
self.password_hash = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def __repr__(self):
return f'<User {self.nickname}>'
class Post(db.Model):
__tablename__ = 'posts'
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(200), nullable=False)
subtitle = db.Column(db.String(300))
content = db.Column(db.Text, nullable=False)
difficulty = db.Column(db.Integer, default=3, nullable=False) # 1-5 scale
media_folder = db.Column(db.String(100)) # Folder name for media files
published = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Foreign Keys
author_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
# Relationships
images = db.relationship('PostImage', backref='post', lazy='dynamic', cascade='all, delete-orphan')
gpx_files = db.relationship('GPXFile', backref='post', lazy='dynamic', cascade='all, delete-orphan')
comments = db.relationship('Comment', backref='post', lazy='dynamic', cascade='all, delete-orphan')
likes = db.relationship('Like', backref='post', lazy='dynamic', cascade='all, delete-orphan')
map_route = db.relationship('MapRoute', backref='post', uselist=False, cascade='all, delete-orphan', passive_deletes=True)
def get_difficulty_label(self):
labels = ['Very Easy', 'Easy', 'Moderate', 'Hard', 'Very Hard']
return labels[self.difficulty - 1] if 1 <= self.difficulty <= 5 else 'Unknown'
def get_like_count(self):
return self.likes.count()
def get_media_folder_path(self):
"""Get the full path to the post's media folder"""
if self.media_folder:
return os.path.join('static', 'media', 'posts', self.media_folder)
return None
def get_media_url_path(self):
"""Get the URL path to the post's media folder"""
if self.media_folder:
return f'/static/media/posts/{self.media_folder}'
return None
def __repr__(self):
return f'<Post {self.title}>'
class PostImage(db.Model):
__tablename__ = 'post_images'
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(255), nullable=False)
original_name = db.Column(db.String(255), nullable=False)
description = db.Column(db.Text)
size = db.Column(db.Integer, nullable=False)
mime_type = db.Column(db.String(100), default='image/jpeg', nullable=False)
is_cover = db.Column(db.Boolean, default=False, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
# Foreign Keys
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
def get_url(self):
"""Get the URL path to access this image"""
if self.post.media_folder:
return f'/static/media/posts/{self.post.media_folder}/images/{self.filename}'
return f'/static/uploads/images/{self.filename}' # Fallback for old files
def get_thumbnail_url(self):
"""Get the URL path to access this image's thumbnail"""
if self.post.media_folder:
return f'/static/media/posts/{self.post.media_folder}/images/thumbnails/{self.filename}'
return self.get_url() # Fallback to main image for old files
def has_thumbnail(self):
"""Check if thumbnail exists for this image"""
if not self.post.media_folder:
return False
from flask import current_app
thumbnail_path = os.path.join(
current_app.root_path, 'static', 'media', 'posts',
self.post.media_folder, 'images', 'thumbnails', self.filename
)
return os.path.exists(thumbnail_path)
def __repr__(self):
return f'<PostImage {self.filename}>'
class GPXFile(db.Model):
__tablename__ = 'gpx_files'
id = db.Column(db.Integer, primary_key=True)
filename = db.Column(db.String(255), nullable=False)
original_name = db.Column(db.String(255), nullable=False)
size = db.Column(db.Integer, nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
# GPX Statistics
total_distance = db.Column(db.Float, default=0.0) # in kilometers
elevation_gain = db.Column(db.Float, default=0.0) # in meters
max_elevation = db.Column(db.Float, default=0.0) # in meters
min_elevation = db.Column(db.Float, default=0.0) # in meters
total_points = db.Column(db.Integer, default=0) # number of track points
# Foreign Keys
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
def get_url(self):
"""Get the URL path to access this GPX file"""
if self.post.media_folder:
return f'/static/media/posts/{self.post.media_folder}/gpx/{self.filename}'
return f'/static/uploads/gpx/{self.filename}' # Fallback for old files
def __repr__(self):
return f'<GPXFile {self.filename}>'
class Comment(db.Model):
__tablename__ = 'comments'
id = db.Column(db.Integer, primary_key=True)
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)
# Foreign Keys
author_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
def __repr__(self):
return f'<Comment {self.id}>'
class Like(db.Model):
__tablename__ = 'likes'
id = db.Column(db.Integer, primary_key=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
# Foreign Keys
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False)
# Unique constraint
__table_args__ = (db.UniqueConstraint('user_id', 'post_id', name='unique_user_post_like'),)
def __repr__(self):
return f'<Like {self.user_id}-{self.post_id}>'
class MapRoute(db.Model):
__tablename__ = 'map_routes'
id = db.Column(db.Integer, primary_key=True)
# Route Data (stored as JSON for efficient loading)
coordinates = db.Column(db.Text, nullable=False) # JSON array of [lat, lng] points
simplified_coordinates = db.Column(db.Text) # Simplified version for map overview
# Route Bounds
start_latitude = db.Column(db.Float, nullable=False)
start_longitude = db.Column(db.Float, nullable=False)
end_latitude = db.Column(db.Float, nullable=False)
end_longitude = db.Column(db.Float, nullable=False)
# Bounding Box for map fitting
bounds_north = db.Column(db.Float, nullable=False)
bounds_south = db.Column(db.Float, nullable=False)
bounds_east = db.Column(db.Float, nullable=False)
bounds_west = db.Column(db.Float, nullable=False)
# Route Statistics (copied from GPX processing)
total_distance = db.Column(db.Float, default=0.0) # in kilometers
elevation_gain = db.Column(db.Float, default=0.0) # in meters
max_elevation = db.Column(db.Float, default=0.0) # in meters
min_elevation = db.Column(db.Float, default=0.0) # in meters
total_points = db.Column(db.Integer, default=0) # original number of points
simplified_points = db.Column(db.Integer, default=0) # simplified points count
# Metadata
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Foreign Keys
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=False, unique=True)
gpx_file_id = db.Column(db.Integer, db.ForeignKey('gpx_files.id'), nullable=False)
# Relationships
# Relationship now defined on Post with cascade and passive_deletes
gpx_file = db.relationship('GPXFile', backref='map_route')
def get_coordinates_json(self):
"""Get coordinates as parsed JSON"""
import json
return json.loads(self.coordinates) if self.coordinates else []
def get_simplified_coordinates_json(self):
"""Get simplified coordinates as parsed JSON"""
import json
return json.loads(self.simplified_coordinates) if self.simplified_coordinates else []
def get_bounds(self):
"""Get bounding box as dict"""
return {
'north': self.bounds_north,
'south': self.bounds_south,
'east': self.bounds_east,
'west': self.bounds_west
}
def get_start_point(self):
"""Get start point as dict"""
return {
'latitude': self.start_latitude,
'longitude': self.start_longitude
}
def get_end_point(self):
"""Get end point as dict"""
return {
'latitude': self.end_latitude,
'longitude': self.end_longitude
}
def __repr__(self):
return f'<MapRoute for Post {self.post_id}>'
class PageView(db.Model):
__tablename__ = 'page_views'
id = db.Column(db.Integer, primary_key=True)
path = db.Column(db.String(255), nullable=False)
user_agent = db.Column(db.String(500))
ip_address = db.Column(db.String(45)) # IPv6 can be up to 45 chars
referer = db.Column(db.String(500))
created_at = db.Column(db.DateTime, default=datetime.utcnow)
# Foreign Keys (optional - for tracking logged-in users)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=True)
post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=True)
# Relationships
user = db.relationship('User', backref='page_views')
post = db.relationship('Post', backref='page_views')
def __repr__(self):
return f'<PageView {self.path} at {self.created_at}>'
# --- Mail Server Management Models ---
class MailSettings(db.Model):
__tablename__ = 'mail_settings'
id = db.Column(db.Integer, primary_key=True)
enabled = db.Column(db.Boolean, default=False, nullable=False)
server = db.Column(db.String(255), nullable=False)
port = db.Column(db.Integer, nullable=False)
use_tls = db.Column(db.Boolean, default=True, nullable=False)
username = db.Column(db.String(255))
password = db.Column(db.String(255))
default_sender = db.Column(db.String(255))
provider = db.Column(db.String(50), default='smtp') # 'smtp' or 'mailrise'
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
def __repr__(self):
return f'<MailSettings {self.server}:{self.port} enabled={self.enabled}>'
class SentEmail(db.Model):
__tablename__ = 'sent_emails'
id = db.Column(db.Integer, primary_key=True)
recipient = db.Column(db.String(255), nullable=False)
subject = db.Column(db.String(255), nullable=False)
body = db.Column(db.Text, nullable=False)
status = db.Column(db.String(50), default='sent') # sent, failed, etc.
error = db.Column(db.Text)
sent_at = db.Column(db.DateTime, default=datetime.utcnow)
provider = db.Column(db.String(50), default='smtp')
def __repr__(self):
return f'<SentEmail to={self.recipient} subject={self.subject} status={self.status}>'
class ChatRoom(db.Model):
__tablename__ = 'chat_rooms'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(200), nullable=False)
description = db.Column(db.Text)
room_type = db.Column(db.String(50), default='general') # general, post_discussion, admin_support, password_reset
is_private = db.Column(db.Boolean, default=False)
is_active = db.Column(db.Boolean, default=True)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
last_activity = db.Column(db.DateTime, default=datetime.utcnow)
# Foreign Keys
created_by_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
related_post_id = db.Column(db.Integer, db.ForeignKey('posts.id'), nullable=True) # For post discussions
# Relationships
created_by = db.relationship('User', backref='created_chat_rooms')
related_post = db.relationship('Post', backref='chat_rooms')
messages = db.relationship('ChatMessage', backref='room', lazy='dynamic', cascade='all, delete-orphan')
participants = db.relationship('ChatParticipant', backref='room', lazy='dynamic', cascade='all, delete-orphan')
def to_dict(self):
"""Convert to dictionary for API responses"""
return {
'id': self.id,
'name': self.name,
'description': self.description,
'room_type': self.room_type,
'is_private': self.is_private,
'is_active': self.is_active,
'created_at': self.created_at.isoformat() if self.created_at else None,
'last_activity': self.last_activity.isoformat() if self.last_activity else None,
'created_by': {
'id': self.created_by.id,
'nickname': self.created_by.nickname
} if self.created_by else None,
'related_post': {
'id': self.related_post.id,
'title': self.related_post.title
} if self.related_post else None,
'participant_count': self.participants.count(),
'message_count': self.messages.count()
}
def __repr__(self):
return f'<ChatRoom {self.name}>'
class ChatParticipant(db.Model):
__tablename__ = 'chat_participants'
id = db.Column(db.Integer, primary_key=True)
joined_at = db.Column(db.DateTime, default=datetime.utcnow)
last_seen = db.Column(db.DateTime, default=datetime.utcnow)
is_muted = db.Column(db.Boolean, default=False)
role = db.Column(db.String(50), default='member') # member, moderator, admin
# Foreign Keys
room_id = db.Column(db.Integer, db.ForeignKey('chat_rooms.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
# Relationships
user = db.relationship('User', backref='chat_participations')
# Unique constraint
__table_args__ = (db.UniqueConstraint('room_id', 'user_id', name='unique_room_participant'),)
def to_dict(self):
"""Convert to dictionary for API responses"""
return {
'id': self.id,
'user': {
'id': self.user.id,
'nickname': self.user.nickname,
'is_admin': self.user.is_admin
},
'role': self.role,
'joined_at': self.joined_at.isoformat() if self.joined_at else None,
'last_seen': self.last_seen.isoformat() if self.last_seen else None,
'is_muted': self.is_muted
}
def __repr__(self):
return f'<ChatParticipant {self.user.nickname} in {self.room.name}>'
class ChatMessage(db.Model):
__tablename__ = 'chat_messages'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.Text, nullable=False)
message_type = db.Column(db.String(50), default='text') # text, system, file, image
is_edited = db.Column(db.Boolean, default=False)
is_deleted = db.Column(db.Boolean, default=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow)
updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
# Foreign Keys
room_id = db.Column(db.Integer, db.ForeignKey('chat_rooms.id'), nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
reply_to_id = db.Column(db.Integer, db.ForeignKey('chat_messages.id'), nullable=True) # For threaded replies
# Relationships
user = db.relationship('User', backref='chat_messages')
reply_to = db.relationship('ChatMessage', remote_side=[id], backref='replies')
def to_dict(self):
"""Convert to dictionary for API responses"""
return {
'id': self.id,
'content': self.content,
'message_type': self.message_type,
'is_edited': self.is_edited,
'is_deleted': self.is_deleted,
'created_at': self.created_at.isoformat() if self.created_at else None,
'updated_at': self.updated_at.isoformat() if self.updated_at else None,
'user': {
'id': self.user.id,
'nickname': self.user.nickname,
'is_admin': self.user.is_admin
},
'reply_to': {
'id': self.reply_to.id,
'content': self.reply_to.content[:100] + '...' if len(self.reply_to.content) > 100 else self.reply_to.content,
'user_nickname': self.reply_to.user.nickname
} if self.reply_to else None
}
def __repr__(self):
return f'<ChatMessage {self.id} by {self.user.nickname}>'
Reference in New Issue View Git Blame Copy Permalink