Upload 6 files

app/__init__.py

@@ -0,0 +1,28 @@
+from flask import Flask
+from flask_cors import CORS
+from config import Config
+from app.utils import markdown_to_html
+from app.extensions import db
+
+def create_app():
+    app = Flask(__name__)
+    app.config.from_object(Config)
+    
+    # Initialize extensions
+    CORS(app)
+    db.init_app(app)
+    
+    # Register Markdown filter
+    app.jinja_env.filters['markdown'] = markdown_to_html
+    
+    # Register blueprints
+    from app.routes import main, admin, api
+    app.register_blueprint(main)
+    app.register_blueprint(admin, url_prefix='/admin')
+    app.register_blueprint(api, url_prefix='/api')
+    
+    # Create database tables
+    with app.app_context():
+        db.create_all()
+    
+    return app

app/ai_service.py

@@ -0,0 +1,37 @@
+from openai import OpenAI
+from flask import current_app
+
+def create_ai_client():
+    """Create AI client with configuration from environment"""
+    return OpenAI(
+        api_key=current_app.config['AI_API_KEY'],
+        base_url=current_app.config['AI_BASE_URL']
+    )
+
+def generate_summary(content):
+    """Generate a summary of the article content"""
+    client = create_ai_client()
+    prompt = f"请为以下文章生成一个简洁的摘要：\n\n{content}"
+    
+    try:
+        response = client.chat.completions.create(
+            model="deepseek-chat",
+            messages=[{"role": "user", "content": prompt}]
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"Error generating summary: {e}")
+        return None
+
+def chat_with_ai(messages):
+    """Chat with AI about the article content"""
+    client = create_ai_client()
+    try:
+        response = client.chat.completions.create(
+            model="deepseek-chat",
+            messages=messages
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        print(f"Error in chat: {e}")
+        return None

app/extensions.py

@@ -0,0 +1,3 @@
+from flask_sqlalchemy import SQLAlchemy
+
+db = SQLAlchemy()

app/models.py

@@ -0,0 +1,37 @@
+from datetime import datetime
+from app.extensions import db
+from slugify import slugify
+import random
+import string
+
+class Article(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)
+    summary = db.Column(db.Text)
+    slug = db.Column(db.String(200), unique=True, nullable=False)
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    def __init__(self, *args, **kwargs):
+        if not kwargs.get('slug') and kwargs.get('title'):
+            base_slug = slugify(kwargs.get('title'))
+            slug = base_slug
+            counter = 1
+            
+            # Keep trying until we find a unique slug
+            while Article.query.filter_by(slug=slug).first() is not None:
+                # Add random string for uniqueness
+                random_string = ''.join(random.choices(string.ascii_lowercase + string.digits, k=4))
+                slug = f"{base_slug}-{random_string}"
+            
+            kwargs['slug'] = slug
+            
+        super().__init__(*args, **kwargs)
+
+class Image(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    filename = db.Column(db.String(200), nullable=False)
+    data = db.Column(db.LargeBinary, nullable=False)  # Store actual image data
+    mime_type = db.Column(db.String(100), nullable=False)  # Store MIME type
+    created_at = db.Column(db.DateTime, default=datetime.utcnow)

app/routes.py

@@ -0,0 +1,186 @@
+from flask import Blueprint, render_template, request, jsonify, redirect, url_for, session, flash, send_file, current_app
+import os
+from app.models import db, Article, Image
+from app.utils import handle_image_upload, login_required, check_auth
+from app.ai_service import generate_summary, chat_with_ai
+import io
+import json
+
+# Blueprints
+main = Blueprint('main', __name__)
+admin = Blueprint('admin', __name__)
+api = Blueprint('api', __name__)
+
+# Main routes
+@main.route('/')
+def index():
+    articles = Article.query.order_by(Article.created_at.desc()).all()
+    return render_template('index.html', articles=articles)
+
+@main.route('/article/<slug>')
+def article(slug):
+    article = Article.query.filter_by(slug=slug).first_or_404()
+    return render_template('article.html', article=article)
+
+# Admin routes
+# @admin.route('/login', methods=['GET', 'POST'])
+# def login():
+#     if request.method == 'POST':
+#         if check_auth(request.form['username'], request.form['password']):
+#             session['logged_in'] = True
+#             return redirect(url_for('admin.dashboard'))
+#         flash('Invalid credentials')
+#     return render_template('admin/login.html')
+@admin.route('/login', methods=['GET', 'POST'])
+def login():
+    if request.method == 'POST':
+        if session.get('logged_in'):
+            session.pop('logged_in', None)
+            flash('已成功退出登录')
+            return redirect(url_for('main.index'))
+            
+        if check_auth(request.form['username'], request.form['password']):
+            session['logged_in'] = True
+            return redirect(url_for('admin.dashboard'))
+        flash('用户名或密码错误')
+    return render_template('admin/login.html')
+@api.route('/search', methods=['GET'])
+def search():
+    query = request.args.get('q', '')
+    if not query:
+        return jsonify({'articles': []})
+    
+    # 简单的模糊搜索：标题或内容包含搜索词
+    articles = Article.query.filter(
+        db.or_(
+            Article.title.ilike(f'%{query}%'),
+            Article.content.ilike(f'%{query}%')
+        )
+    ).order_by(Article.created_at.desc()).all()
+    
+    # 转换为JSON格式
+    articles_data = [{
+        'title': article.title,
+        'summary': article.summary,
+        'slug': article.slug,
+        'created_at': article.created_at.strftime('%Y-%m-%d')
+    } for article in articles]
+    
+    return jsonify({'articles': articles_data})
+@admin.route('/dashboard')
+@login_required
+def dashboard():
+    articles = Article.query.order_by(Article.created_at.desc()).all()
+    return render_template('admin/dashboard.html', articles=articles)
+
+@admin.route('/editor', defaults={'slug': None})
+@admin.route('/editor/<slug>')
+@login_required
+def editor(slug):
+    article = Article.query.filter_by(slug=slug).first() if slug else None
+    return render_template('editor.html', article=article)
+
+# API routes
+@api.route('/articles', methods=['POST'])
+@login_required
+def create_article():
+    try:
+        data = request.get_json()
+        if not data or 'title' not in data or 'content' not in data:
+            return jsonify({'error': '标题和内容不能为空'}), 400
+            
+        article = Article(
+            title=data['title'],
+            content=data['content']
+        )
+        article.summary = generate_summary(data['content'])
+        db.session.add(article)
+        db.session.commit()
+        return jsonify({'slug': article.slug})
+    except Exception as e:
+        db.session.rollback()
+        return jsonify({'error': str(e)}), 500
+
+@api.errorhandler(500)
+def handle_500(error):
+    return jsonify({'error': '服务器内部错误'}), 500
+
+@api.route('/articles/<slug>', methods=['PUT'])
+@login_required
+def update_article(slug):
+    article = Article.query.filter_by(slug=slug).first_or_404()
+    data = request.get_json()
+    article.title = data['title']
+    article.content = data['content']
+    article.summary = generate_summary(data['content'])
+    db.session.commit()
+    return jsonify({'success': True})
+
+@api.route('/articles/<slug>', methods=['DELETE'])
+@login_required
+def delete_article(slug):
+    article = Article.query.filter_by(slug=slug).first_or_404()
+    db.session.delete(article)
+    db.session.commit()
+    return jsonify({'success': True})
+
+@api.route('/upload', methods=['POST'])
+@login_required
+def upload():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file provided'}), 400
+    
+    file = request.files['file']
+    path = handle_image_upload(file)
+    
+    if path:
+        return jsonify({'url': path})
+    
+    return jsonify({'error': 'Invalid file'}), 400
+
+@api.route('/images/<int:image_id>')
+def get_image(image_id):
+    image = Image.query.get_or_404(image_id)
+    return send_file(
+        io.BytesIO(image.data),
+        mimetype=image.mime_type,
+        as_attachment=False
+    )
+
+@api.route('/chat', methods=['POST'])
+def chat():
+    data = request.get_json()
+    response = chat_with_ai(data['messages'])
+    return jsonify({'response': response})
+
+@api.route('/export', methods=['GET'])
+@login_required
+def export_data():
+    db_path = os.path.join(current_app.root_path, '..', 'instance', 'blog.db')
+    return send_file(
+        db_path,
+        as_attachment=True,
+        download_name='blog-backup.db',
+        mimetype='application/x-sqlite3'
+    )
+
+@api.route('/import', methods=['POST'])
+@login_required
+def import_data():
+    if 'file' not in request.files:
+        return jsonify({'error': 'No file provided'}), 400
+        
+    file = request.files['file']
+    if file.filename == '':
+        return jsonify({'error': 'No file selected'}), 400
+        
+    if not file.filename.endswith('.db'):
+        return jsonify({'error': 'Invalid file type'}), 400
+        
+    try:
+        db_path = os.path.join(current_app.root_path, '..', 'instance', 'blog.db')
+        file.save(db_path)
+        db.session.remove()  # Close any existing connections
+        return jsonify({'success': True})
+    except Exception as e:
+        return jsonify({'error': str(e)}), 500

app/utils.py

@@ -0,0 +1,45 @@
+import os
+from werkzeug.utils import secure_filename
+from functools import wraps
+from flask import current_app, request, redirect, url_for, session, send_file
+import markdown
+from markupsafe import Markup
+from app.extensions import db
+from app.models import Image
+import io
+
+def markdown_to_html(text):
+    return Markup(markdown.markdown(text, extensions=['fenced_code', 'tables']))
+
+def allowed_file(filename):
+    """Check if uploaded file has allowed extension"""
+    return '.' in filename and \
+           filename.rsplit('.', 1)[1].lower() in current_app.config['ALLOWED_EXTENSIONS']
+
+def handle_image_upload(file):
+    """Handle image upload and store in database"""
+    if file and allowed_file(file.filename):
+        filename = secure_filename(file.filename)
+        image = Image(
+            filename=filename,
+            data=file.read(),
+            mime_type=file.content_type
+        )
+        db.session.add(image)
+        db.session.commit()
+        return f'/api/images/{image.id}'
+    return None
+
+def login_required(f):
+    """Decorator to require login for admin routes"""
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if not session.get('logged_in'):
+            return redirect(url_for('admin.login'))
+        return f(*args, **kwargs)
+    return decorated_function
+
+def check_auth(username, password):
+    """Check if username and password match environment variables"""
+    return (username == current_app.config['ADMIN_USERNAME'] and 
+            password == current_app.config['ADMIN_PASSWORD'])