59 |
163 | {% endblock %} {% block scripts %}
164 |
235 | {% endblock %}
236 |
--------------------------------------------------------------------------------
/app/templates/admin/users.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %} {% block title %}用户管理 - 提示词管理平台{% endblock
2 | %} {% block styles %}
3 |
173 | {% endblock %} {% block content %}
174 |
60 |
162 |
61 |
67 |
68 |
62 |
63 |
64 | 创建新账号
65 |加入提示词管理平台
66 |
69 |
160 |
161 |
175 |
282 | {% endblock %}
283 |
--------------------------------------------------------------------------------
/app/services/prompt_service.py:
--------------------------------------------------------------------------------
1 | """
2 | 提示词业务逻辑
3 | """
4 | from app.database import get_db
5 | from app.services.tag_service import link_tags_to_prompt
6 | from app.utils.helpers import format_datetime
7 |
8 |
9 | def create_prompt(user_id, title, content, description, version, is_public, tag_names):
10 | """创建提示词"""
11 | db = get_db()
12 |
13 | # 插入提示词
14 | db.execute(
15 | 'INSERT INTO prompts (title, content, description, version, user_id, is_public) VALUES (?, ?, ?, ?, ?, ?)',
16 | (title, content, description, version, user_id, is_public)
17 | )
18 | prompt_id = db.execute('SELECT last_insert_rowid()').fetchone()[0]
19 |
20 | # 处理标签
21 | link_tags_to_prompt(db, prompt_id, tag_names)
22 |
23 | db.commit()
24 | return prompt_id
25 |
26 |
27 | def update_prompt(prompt_id, user_id, title, content, description, version, is_public, tag_names):
28 | """更新提示词"""
29 | db = get_db()
30 |
31 | # 检查权限
32 | prompt = db.execute('SELECT user_id FROM prompts WHERE id = ?', (prompt_id,)).fetchone()
33 | if not prompt or prompt['user_id'] != user_id:
34 | raise PermissionError('您没有权限编辑此提示词')
35 |
36 | # 更新提示词
37 | db.execute(
38 | 'UPDATE prompts SET title = ?, content = ?, description = ?, version = ?, is_public = ?, updated_at = CURRENT_TIMESTAMP WHERE id = ?',
39 | (title, content, description, version, is_public, prompt_id)
40 | )
41 |
42 | # 删除旧标签关联
43 | db.execute('DELETE FROM tags_prompts WHERE prompt_id = ?', (prompt_id,))
44 |
45 | # 添加新标签
46 | link_tags_to_prompt(db, prompt_id, tag_names)
47 |
48 | db.commit()
49 |
50 |
51 | def delete_prompt(prompt_id, user_id, is_admin=False):
52 | """删除提示词"""
53 | db = get_db()
54 |
55 | prompt = db.execute('SELECT * FROM prompts WHERE id = ?', (prompt_id,)).fetchone()
56 | if not prompt:
57 | raise ValueError('提示词不存在')
58 |
59 | # 检查权限
60 | if not is_admin and prompt['user_id'] != user_id:
61 | raise PermissionError('您没有权限删除此提示词')
62 |
63 | # 删除标签关联
64 | db.execute('DELETE FROM tags_prompts WHERE prompt_id = ?', (prompt_id,))
65 |
66 | # 删除收藏关联
67 | db.execute('DELETE FROM favorites WHERE prompt_id = ?', (prompt_id,))
68 |
69 | # 删除提示词
70 | db.execute('DELETE FROM prompts WHERE id = ?', (prompt_id,))
71 |
72 | db.commit()
73 |
74 |
75 | def get_prompt_by_id(prompt_id, user_id=None):
76 | """根据ID获取提示词"""
77 | db = get_db()
78 | prompt = db.execute(
79 | 'SELECT p.*, u.username, u.avatar_url FROM prompts p JOIN users u ON p.user_id = u.id WHERE p.id = ?',
80 | (prompt_id,)
81 | ).fetchone()
82 |
83 | if not prompt:
84 | return None
85 |
86 | prompt = dict(prompt)
87 |
88 | # 格式化日期时间
89 | if 'created_at' in prompt and prompt['created_at']:
90 | prompt['created_at'] = format_datetime(prompt['created_at'])
91 | if 'updated_at' in prompt and prompt['updated_at']:
92 | prompt['updated_at'] = format_datetime(prompt['updated_at'])
93 |
94 | # 检查权限
95 | if not prompt['is_public'] and (not user_id or user_id != prompt['user_id']):
96 | return None
97 |
98 | # 获取标签
99 | tags = db.execute(
100 | 'SELECT t.* FROM tags t JOIN tags_prompts tp ON t.id = tp.tag_id WHERE tp.prompt_id = ?',
101 | (prompt_id,)
102 | ).fetchall()
103 | prompt['tags'] = tags
104 |
105 | # 更新浏览计数
106 | db.execute('UPDATE prompts SET view_count = view_count + 1 WHERE id = ?', (prompt_id,))
107 | db.commit()
108 |
109 | return prompt
110 |
111 |
112 | def get_user_prompts(user_id, page=1, per_page=9):
113 | """获取用户的提示词列表"""
114 | db = get_db()
115 |
116 | # 计算总数
117 | total_count = db.execute(
118 | 'SELECT COUNT(*) as count FROM prompts WHERE user_id = ?',
119 | (user_id,)
120 | ).fetchone()['count']
121 |
122 | # 计算总页数
123 | total_pages = (total_count + per_page - 1) // per_page
124 |
125 | # 确保page在有效范围内
126 | if page < 1:
127 | page = 1
128 | elif page > total_pages and total_pages > 0:
129 | page = total_pages
130 |
131 | # 获取提示词数据
132 | prompt_rows = db.execute(
133 | 'SELECT p.*, u.username FROM prompts p JOIN users u ON p.user_id = u.id WHERE p.user_id = ? ORDER BY p.created_at DESC LIMIT ? OFFSET ?',
134 | (user_id, per_page, (page - 1) * per_page)
135 | ).fetchall()
136 |
137 | prompts = [dict(row) for row in prompt_rows]
138 |
139 | # 获取所有提示词的标签
140 | for prompt in prompts:
141 | tags = db.execute(
142 | 'SELECT t.* FROM tags t '
143 | 'JOIN tags_prompts tp ON t.id = tp.tag_id '
144 | 'WHERE tp.prompt_id = ?',
145 | (prompt['id'],)
146 | ).fetchall()
147 | prompt['tags'] = tags
148 |
149 | # 格式化日期时间
150 | if 'created_at' in prompt and prompt['created_at']:
151 | prompt['created_at'] = format_datetime(prompt['created_at'])
152 | if 'updated_at' in prompt and prompt['updated_at']:
153 | prompt['updated_at'] = format_datetime(prompt['updated_at'])
154 |
155 | return {
156 | 'prompts': prompts,
157 | 'current_page': page,
158 | 'total_pages': total_pages,
159 | 'total_count': total_count
160 | }
161 |
162 |
163 | def get_public_prompts(page=1, per_page=9, search_query=None, tag_filter=None):
164 | """获取公开提示词列表"""
165 | db = get_db()
166 |
167 | # 构建查询
168 | query = 'SELECT p.*, u.username, u.avatar_url FROM prompts p JOIN users u ON p.user_id = u.id WHERE p.is_public = 1'
169 | params = []
170 |
171 | if search_query:
172 | query += ' AND (p.title LIKE ? OR p.description LIKE ?)'
173 | search_pattern = f'%{search_query}%'
174 | params.extend([search_pattern, search_pattern])
175 |
176 | if tag_filter:
177 | query += ' AND p.id IN (SELECT tp.prompt_id FROM tags_prompts tp JOIN tags t ON tp.tag_id = t.id WHERE t.name = ?)'
178 | params.append(tag_filter)
179 |
180 | # 计算总数
181 | count_query = query.replace('SELECT p.*, u.username, u.avatar_url', 'SELECT COUNT(*) as count')
182 | total_count = db.execute(count_query, params).fetchone()['count']
183 |
184 | # 计算总页数
185 | total_pages = (total_count + per_page - 1) // per_page
186 |
187 | # 确保page在有效范围内
188 | if page < 1:
189 | page = 1
190 | elif page > total_pages and total_pages > 0:
191 | page = total_pages
192 |
193 | # 添加排序和分页
194 | query += ' ORDER BY p.view_count DESC, p.created_at DESC LIMIT ? OFFSET ?'
195 | params.extend([per_page, (page - 1) * per_page])
196 |
197 | # 获取提示词数据
198 | prompt_rows = db.execute(query, params).fetchall()
199 |
200 | prompts = [dict(row) for row in prompt_rows]
201 |
202 | # 获取所有提示词的标签
203 | for prompt in prompts:
204 | tags = db.execute(
205 | 'SELECT t.* FROM tags t '
206 | 'JOIN tags_prompts tp ON t.id = tp.tag_id '
207 | 'WHERE tp.prompt_id = ?',
208 | (prompt['id'],)
209 | ).fetchall()
210 | prompt['tags'] = tags
211 |
212 | # 格式化日期时间
213 | if 'created_at' in prompt and prompt['created_at']:
214 | prompt['created_at'] = format_datetime(prompt['created_at'])
215 | if 'updated_at' in prompt and prompt['updated_at']:
216 | prompt['updated_at'] = format_datetime(prompt['updated_at'])
217 |
218 | return {
219 | 'prompts': prompts,
220 | 'current_page': page,
221 | 'total_pages': total_pages,
222 | 'total_count': total_count
223 | }
224 |
225 |
226 | def is_favorited(user_id, prompt_id):
227 | """检查用户是否已收藏提示词"""
228 | if not user_id:
229 | return False
230 |
231 | db = get_db()
232 | favorite = db.execute(
233 | 'SELECT * FROM favorites WHERE user_id = ? AND prompt_id = ?',
234 | (user_id, prompt_id)
235 | ).fetchone()
236 |
237 | return favorite is not None
238 |
239 |
240 | def toggle_favorite(user_id, prompt_id):
241 | """切换收藏状态"""
242 | db = get_db()
243 |
244 | favorite = db.execute(
245 | 'SELECT * FROM favorites WHERE user_id = ? AND prompt_id = ?',
246 | (user_id, prompt_id)
247 | ).fetchone()
248 |
249 | if favorite:
250 | # 取消收藏
251 | db.execute('DELETE FROM favorites WHERE user_id = ? AND prompt_id = ?', (user_id, prompt_id))
252 | is_favorited = False
253 | else:
254 | # 添加收藏
255 | db.execute('INSERT INTO favorites (user_id, prompt_id) VALUES (?, ?)', (user_id, prompt_id))
256 | is_favorited = True
257 |
258 | db.commit()
259 | return is_favorited
260 |
261 |
--------------------------------------------------------------------------------
/app/services/ai_service.py:
--------------------------------------------------------------------------------
1 | """
2 | AI 服务层
3 | 提供统一的 AI 元数据生成接口
4 | """
5 | import json
6 | import re
7 | from typing import Dict
8 | from flask import current_app
9 | from app.services.ai.base_client import BaseAIClient
10 |
11 |
12 | # 提示词模板（固定规则）
13 | METADATA_GENERATION_PROMPT = """你是一个专业的提示词管理助手。请根据用户提供的提示词内容，生成以下信息：
14 |
15 | 1. **标题**：一个简洁、准确的标题，能够概括提示词的核心功能或用途
16 | - 要求：不超过30个字符，使用中文
17 | - 风格：专业、简洁、易于理解
18 |
19 | 2. **描述**：一段简要的描述，说明这个提示词的用途、适用场景和特点
20 | - 要求：必须100-150个字符之间，使用中文
21 | - 内容：详细说明用途、适用场景、主要特点，确保描述充分且完整
22 | - 重要：描述字数必须严格控制在100-150字符之间，不能少于100字符，不能超过150字符
23 |
24 | 3. **标签**：生成5个相关标签，用于分类和搜索
25 | - 要求：标签使用中文或英文（技术术语）
26 | - 类型：技术标签、功能标签、场景标签
27 | - 每个标签长度2-8个字符
28 |
29 | **输出格式**：必须严格按照以下 JSON 格式返回，不要包含任何其他文字说明：
30 |
31 | ```json
32 | {{
33 | "title": "标题内容",
34 | "description": "描述内容",
35 | "tags": ["标签1", "标签2", "标签3", "标签4", "标签5"]
36 | }}
37 | ```
38 |
39 | **用户提供的提示词内容**：
40 | {prompt_content}
41 |
42 | 请开始分析并生成元数据："""
43 |
44 |
45 | class AIService:
46 | """AI 服务类"""
47 |
48 | def __init__(self, client: BaseAIClient):
49 | """
50 | 初始化 AI 服务
51 |
52 | :param client: AI 客户端实例
53 | """
54 | self.client = client
55 |
56 | def generate_metadata(self, prompt_content: str) -> Dict:
57 | """
58 | 根据提示词内容生成元数据
59 |
60 | :param prompt_content: 提示词内容
61 | :return: 包含 title, description, tags 的字典
62 | :raises ValueError: 如果输入无效或生成失败
63 | """
64 | # 固定配置
65 | title_max_length = 30
66 | description_max_length = 150 # 最大150字符
67 | description_min_length = 100 # 最小100字符
68 | tag_count = 5
69 | tag_two_char_count = 0
70 | tag_four_char_count = 0
71 | # 验证输入
72 | if not prompt_content or len(prompt_content.strip()) == 0:
73 | raise ValueError("提示词内容不能为空")
74 |
75 | if len(prompt_content) > 10000:
76 | raise ValueError("提示词内容过长（最大10000字符）")
77 |
78 | # 构建提示词（使用固定规则）
79 | full_prompt = self._build_prompt(prompt_content=prompt_content)
80 |
81 | # 计算合适的 max_tokens
82 | # 标题大约需要 50 tokens，描述需要更多（150字符约300 tokens），标签每个约 10 tokens
83 | # 加上 JSON 格式的开销，总需求约为：50 + 300 + tag_count * 10 + 100
84 | estimated_tokens = 50 + 300 + (tag_count * 10) + 100
85 | # 确保至少 500，最多不超过 2000
86 | max_tokens = max(500, min(estimated_tokens, 2000))
87 |
88 | # 调用 AI API
89 | messages = [
90 | {"role": "system", "content": "你是一个专业的提示词管理助手，擅长分析提示词内容并生成准确的元数据。"},
91 | {"role": "user", "content": full_prompt}
92 | ]
93 |
94 | try:
95 | response = self.client.chat_completion(messages, max_tokens=max_tokens)
96 | content = self.client.extract_text_from_response(response)
97 |
98 | # 解析 JSON 响应
99 | metadata = self._parse_response(content)
100 |
101 | # 验证和清理数据（使用固定参数）
102 | metadata = self._validate_and_clean_metadata(
103 | metadata,
104 | title_max_length=title_max_length,
105 | description_min_length=description_min_length,
106 | description_max_length=description_max_length,
107 | tag_count=tag_count,
108 | tag_two_char_count=tag_two_char_count,
109 | tag_four_char_count=tag_four_char_count
110 | )
111 |
112 | return metadata
113 |
114 | except json.JSONDecodeError as e:
115 | raise ValueError(f"AI 返回的 JSON 格式错误: {str(e)}")
116 | except Exception as e:
117 | raise Exception(f"生成元数据失败: {str(e)}")
118 |
119 | def _build_prompt(self, prompt_content: str) -> str:
120 | """
121 | 构建提示词（使用固定规则）
122 |
123 | :param prompt_content: 提示词内容
124 | :return: 完整的提示词
125 | """
126 | return METADATA_GENERATION_PROMPT.format(
127 | prompt_content=prompt_content
128 | )
129 |
130 | def _parse_response(self, content: str) -> Dict:
131 | """
132 | 解析 AI 返回的内容
133 |
134 | :param content: AI 返回的文本内容
135 | :return: 解析后的字典
136 | :raises ValueError: 如果无法解析 JSON
137 | """
138 | # 尝试直接解析 JSON
139 | try:
140 | # 移除可能的代码块标记
141 | content = re.sub(r'```json\s*', '', content)
142 | content = re.sub(r'```\s*', '', content)
143 | content = content.strip()
144 |
145 | return json.loads(content)
146 | except json.JSONDecodeError:
147 | # 如果直接解析失败，尝试提取 JSON 部分
148 | json_match = re.search(r'\{[^{}]*"title"[^{}]*\}', content, re.DOTALL)
149 | if json_match:
150 | return json.loads(json_match.group())
151 | raise ValueError("无法从响应中提取有效的 JSON 数据")
152 |
153 | def _validate_and_clean_metadata(self, metadata: Dict,
154 | title_max_length: int = 30,
155 | description_min_length: int = 100,
156 | description_max_length: int = 150,
157 | tag_count: int = 5,
158 | tag_two_char_count: int = 0,
159 | tag_four_char_count: int = 0) -> Dict:
160 | """
161 | 验证和清理元数据
162 |
163 | :param metadata: AI 返回的元数据
164 | :param title_max_length: 标题最大字数
165 | :param description_max_length: 描述最大字数
166 | :param tag_count: 标签总数
167 | :param tag_two_char_count: 两字标签个数
168 | :param tag_four_char_count: 四字标签个数
169 | :return: 清理后的元数据
170 | :raises ValueError: 如果数据无效
171 | """
172 | # 验证必需字段
173 | if 'title' not in metadata or 'description' not in metadata or 'tags' not in metadata:
174 | raise ValueError("AI 返回的数据缺少必需字段")
175 |
176 | # 清理标题（使用配置的长度限制）
177 | title = str(metadata['title']).strip()
178 | if len(title) > title_max_length:
179 | title = title[:title_max_length]
180 | if not title:
181 | raise ValueError("标题不能为空")
182 |
183 | # 清理描述（使用固定的长度限制：100-150字符）
184 | description = str(metadata['description']).strip()
185 | if len(description) > description_max_length:
186 | description = description[:description_max_length]
187 | elif len(description) < description_min_length:
188 | # 如果描述太短，提示但不强制（因为可能是 AI 生成的问题）
189 | current_app.logger.warning(f"描述字数不足：{len(description)} < {description_min_length}")
190 | if not description:
191 | raise ValueError("描述不能为空")
192 |
193 | # 清理标签（根据配置规则）
194 | tags = metadata.get('tags', [])
195 | if not isinstance(tags, list):
196 | tags = [tags] if tags else []
197 |
198 | # 过滤和清理标签
199 | cleaned_tags = []
200 | two_char_tags = []
201 | four_char_tags = []
202 | other_tags = []
203 |
204 | for tag in tags:
205 | tag = str(tag).strip()
206 | if not tag or len(tag) < 2 or len(tag) > 20:
207 | continue
208 |
209 | if len(tag) == 2:
210 | two_char_tags.append(tag)
211 | elif len(tag) == 4:
212 | four_char_tags.append(tag)
213 | else:
214 | other_tags.append(tag)
215 |
216 | # 按照配置规则选择标签
217 | if tag_two_char_count > 0:
218 | cleaned_tags.extend(two_char_tags[:tag_two_char_count])
219 | if tag_four_char_count > 0:
220 | cleaned_tags.extend(four_char_tags[:tag_four_char_count])
221 |
222 | # 填充剩余标签
223 | remaining = tag_count - len(cleaned_tags)
224 | if remaining > 0:
225 | all_remaining = two_char_tags[tag_two_char_count:] + \
226 | four_char_tags[tag_four_char_count:] + \
227 | other_tags
228 | cleaned_tags.extend(all_remaining[:remaining])
229 |
230 | # 确保标签数量在合理范围内
231 | if len(cleaned_tags) < 1:
232 | raise ValueError("至少需要一个标签")
233 | if len(cleaned_tags) > tag_count:
234 | cleaned_tags = cleaned_tags[:tag_count]
235 |
236 | return {
237 | 'title': title,
238 | 'description': description,
239 | 'tags': cleaned_tags
240 | }
241 |
242 | def test_connection(self) -> bool:
243 | """
244 | 测试 API 连接
245 |
246 | :return: True 如果连接成功，False 否则
247 | """
248 | return self.client.test_connection()
249 |
250 |
--------------------------------------------------------------------------------
/app/templates/search.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %} {% block title %}搜索结果 - 提示词管理平台{% endblock
2 | %} {% block styles %}
3 |
228 | {% endblock %} {% block content %}
229 |
176 |
183 |
184 |
177 |
181 |
182 |
178 |
180 | 用户管理
179 |181 |
185 |
281 |
186 |
280 |
187 |
279 |
188 |
278 | 用户列表
189 | ← 左右滑动查看更多 → 190 |
191 |
192 |
193 |
276 |
277 | | ID | 195 |用户名 | 196 |邮箱 | 197 |注册时间 | 198 |身份 | 199 |状态 | 200 |操作 | 201 |
|---|---|---|---|---|---|---|
| {{ user.id }} | 207 |{{ user.username }} | 208 |{{ user.email }} | 209 |{{ user.created_at }} | 210 |211 | {% if user.is_admin %} 212 | 管理员 213 | {% else %} 214 | 普通用户 215 | {% endif %} 216 | | 217 |218 | {% if user.is_banned %} 219 | 已封禁 220 | {% else %} 221 | 正常 222 | {% endif %} 223 | | 224 |
225 | {% if not user.is_admin %}
226 |
227 |
251 |
263 |
264 | {% else %}
265 | 无操作
266 | {% endif %}
267 | |
268 |
| 暂无用户 | 272 |||||||
230 |
314 | {% endblock %} {% block scripts %}
315 |
343 | {% endblock %}
344 |
--------------------------------------------------------------------------------
/app/templates/admin/invite_codes.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %} {% block title %}邀请码管理 - 提示词管理平台{%
2 | endblock %} {% block styles %}
3 |
124 | {% endblock %} {% block content %}
125 |
231 |
246 |
247 |
232 |
244 |
245 |
233 |
243 | 234 | 搜索结果 {% if query or selected_tag %} 235 | 236 | {% if query %}关键词: "{{ query }}"{% endif %} {% if query and 237 | selected_tag %} 和 {% endif %} {% if selected_tag %}标签: "{{ 238 | selected_tag }}"{% endif %} 239 | 240 | {% endif %} 241 |
242 |244 |
248 |
313 |
249 |
312 |
250 | {% if prompts %} {% for prompt in prompts %}
251 |
311 |
255 |
298 | {% endfor %} {% else %}
299 |
309 | {% endif %}
310 |
256 |
263 | {{ prompt.title }}
257 | 260 | {% if prompt.is_public %}公开{% else %}私有{% endif %} 261 | 262 |
264 |
278 |
297 | {{ prompt.description or '无描述' }}
265 | {% if prompt.tags %} 266 |
267 | {% for tag in prompt.tags %}
268 | {{ tag.name }}
274 | {% endfor %}
275 |
276 | {% endif %}
277 |
126 |
259 | {% endblock %} {% block scripts %}
260 |
325 | {% endblock %}
326 |
--------------------------------------------------------------------------------
/app/templates/user/profile.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %} {% block title %}{{ profile_user.username }}
2 | 的个人资料 - 提示词管理平台{% endblock %} {% block styles %}
3 |
263 | {% endblock %} {% block content %}
264 |
127 |
134 |
135 |
128 |
132 |
133 |
129 |
131 | 邀请码管理
130 |132 |
136 |
169 |
170 |
137 |
168 |
138 |
167 |
139 |
166 | 生成新邀请码
140 | 165 |
171 |
258 |
172 |
257 |
173 |
256 |
174 |
254 |
255 |
265 |
266 |
380 | {% endblock %}
381 |
--------------------------------------------------------------------------------
/app/templates/prompts/my_prompts.html:
--------------------------------------------------------------------------------
1 | {% extends 'base.html' %} {% block title %}我的提示词 - 提示词管理平台{%
2 | endblock %} {% block styles %}
3 |
277 | {% endblock %} {% block content %}
278 |
267 |
318 |
319 |
320 |
268 |
317 |
269 |
281 |
270 | {% if profile_user.avatar_url %}
271 | 
276 | {% else %}
277 |
278 | {% endif %}
279 |
280 |
282 |
316 |
283 |
294 | {{ profile_user.username }}
284 | {% if session.user_id == profile_user.id %} 285 | 289 | 编辑资料 291 | 292 | {% endif %} 293 |{{ profile_user.email }}
295 |296 | 注册于 {% if 297 | profile_user.created_at %} {{ profile_user.created_at }} {% else %} 298 | 未知时间 {% endif %} 299 |
300 | 301 |
302 |
315 |
303 |
306 | {{ prompts_count }}
304 |提示词
305 |
307 |
310 | {{ likes_count }}
308 |收藏
309 |
311 |
314 | {{ views_count }}
312 |浏览量
313 |
321 | 收藏的提示词
322 |
323 |
324 |
325 | {% if prompts %}
326 |
327 | {% for prompt in prompts %}
328 |
372 | {% else %}
373 |
378 | {% endif %}
379 |
329 |
370 | {% endfor %}
371 |
332 |
336 | {{ prompt.title }}
337 |
338 | {% if prompt.is_public %}
339 | 公开
340 | {% else %}
341 | 私有
342 | {% endif %}
343 |
344 |
345 |
352 |
369 | {{ prompt.description }}
346 |
347 | {% if prompt.tags %} {% for tag in prompt.tags %}
348 | {{ tag }}
349 | {% endfor %} {% endif %}
350 |
351 |
279 |
399 | {% endblock %} {% block scripts %}
400 |
418 | {% endblock %}
419 |
--------------------------------------------------------------------------------
/app/routes/user.py:
--------------------------------------------------------------------------------
1 | """
2 | 用户相关路由
3 | """
4 | from flask import Blueprint, render_template, redirect, url_for, flash, request, session, jsonify
5 | from werkzeug.security import generate_password_hash, check_password_hash
6 | from app.database import get_db
7 | from app.utils.decorators import login_required
8 | from app.utils.helpers import format_datetime
9 | from app.utils.file_upload import save_avatar
10 | from app.utils.encryption import encrypt_string, decrypt_string
11 | from app.services.ai.factory import AIClientFactory
12 | from flask import current_app
13 | import datetime
14 |
15 | bp = Blueprint('user', __name__)
16 |
17 |
18 | @bp.route('/profile/
280 |
281 |
398 |
282 |
397 |
283 | {% for prompt in prompts %}
284 |
337 |
338 | {% if prompts %}
339 |
288 |
335 | {% endfor %}
336 |
289 |
296 | {{ prompt.title }}
290 | 293 | {% if prompt.is_public %}公开{% else %}私有{% endif %} 294 | 295 |
297 |
311 |
334 | {{ prompt.description or '无描述' }}
298 | {% if prompt.tags %} 299 |
300 | {% for tag in prompt.tags %}
301 | {{ tag.name }}
307 | {% endfor %}
308 |
309 | {% endif %}
310 |
340 |
380 |
381 |
382 | 显示第 {{ (current_page - 1) * 9 + 1 }} 到 {% if current_page * 9 >
383 | total_count %} {{ total_count }} {% else %} {{ current_page * 9 }} {%
384 | endif %} 条，共 {{ total_count }} 条
385 |
386 | {% else %}
387 |
388 |
392 |
395 | {% endif %}
396 | 您还没有创建任何提示词
393 |开始创建你的第一个提示词吧！
394 |
100 |
272 | {% endblock %} {% block scripts %}
273 |
367 | {% endblock %}
368 |
369 |
--------------------------------------------------------------------------------
/app/static/js/main.js:
--------------------------------------------------------------------------------
1 | /**
2 | * 提示词管理平台 - 主JavaScript文件
3 | */
4 |
5 | // 等待文档加载完成
6 | document.addEventListener("DOMContentLoaded", function () {
7 | // 初始化所有功能
8 | initTooltips();
9 | initAnimations();
10 | initCopyButtons();
11 | initTagEffects();
12 | initFlashMessages();
13 | initFormValidation();
14 | initImagePreview();
15 | initScrollNavbar();
16 | initCardAnimations();
17 | initPageTransitions();
18 | initStaggeredItems();
19 |
20 | // 删除此处的回到顶部按钮代码，避免冲突
21 | console.log("main.js初始化完成，回到顶部按钮已由HTML内联脚本处理");
22 | });
23 |
24 | /**
25 | * 初始化 Bootstrap 工具提示
26 | */
27 | function initTooltips() {
28 | const tooltipTriggerList = document.querySelectorAll(
29 | '[data-bs-toggle="tooltip"]'
30 | );
31 | if (tooltipTriggerList.length > 0 && typeof bootstrap !== "undefined") {
32 | tooltipTriggerList.forEach(function (tooltipTriggerEl) {
33 | new bootstrap.Tooltip(tooltipTriggerEl);
34 | });
35 | console.log("工具提示已初始化");
36 | }
37 | }
38 |
39 | /**
40 | * 初始化动画效果
41 | */
42 | function initAnimations() {
43 | const mainContent = document.querySelector("main");
44 | if (mainContent) {
45 | mainContent.classList.add("fade-in");
46 | }
47 |
48 | const headings = document.querySelectorAll("h1, h2, h3");
49 | headings.forEach(function (heading) {
50 | heading.classList.add("fadeIn");
51 | });
52 | }
53 |
54 | /**
55 | * 初始化复制按钮功能
56 | */
57 | function initCopyButtons() {
58 | const copyButtons = document.querySelectorAll("[data-copy-target]");
59 |
60 | copyButtons.forEach(function (button) {
61 | button.addEventListener("click", function () {
62 | const targetId = button.getAttribute("data-copy-target");
63 | const targetElement = document.getElementById(targetId);
64 |
65 | if (targetElement) {
66 | if (
67 | targetElement.tagName === "INPUT" ||
68 | targetElement.tagName === "TEXTAREA"
69 | ) {
70 | copyToClipboard(targetElement.value, button);
71 | } else {
72 | copyToClipboard(targetElement.textContent, button);
73 | }
74 | }
75 | });
76 | });
77 |
78 | const copyTextButtons = document.querySelectorAll("[data-copy-text]");
79 |
80 | copyTextButtons.forEach(function (button) {
81 | button.addEventListener("click", function () {
82 | const text = button.getAttribute("data-copy-text");
83 | copyToClipboard(text, button);
84 | });
85 | });
86 | }
87 |
88 | /**
89 | * 复制内容到剪贴板
90 | */
91 | function copyToClipboard(text, button) {
92 | // 保存原始按钮文本，用于恢复
93 | const originalText = button.innerHTML;
94 |
95 | // 检查是否支持现代Clipboard API
96 | if (navigator.clipboard && window.isSecureContext) {
97 | // 使用现代Clipboard API
98 | navigator.clipboard
99 | .writeText(text)
100 | .then(() => {
101 | // 复制成功
102 | button.innerHTML = ' 已复制';
103 |
104 | // 显示成功消息（可选）
105 | if (window.innerWidth < 768) {
106 | // 移动端显示toast提示
107 | showToast("复制成功", "success");
108 | }
109 |
110 | // 2秒后恢复按钮原样
111 | setTimeout(function () {
112 | button.innerHTML = originalText;
113 | }, 2000);
114 | })
115 | .catch((err) => {
116 | console.error("复制失败:", err);
117 | button.innerHTML =
118 | ' 复制失败';
119 |
120 | // 添加备用复制方法
121 | fallbackCopyToClipboard(text, button, originalText);
122 |
123 | setTimeout(function () {
124 | button.innerHTML = originalText;
125 | }, 2000);
126 | });
127 | } else {
128 | // 对于不支持Clipboard API的浏览器，使用备用方法
129 | fallbackCopyToClipboard(text, button, originalText);
130 | }
131 | }
132 |
133 | /**
134 | * 备用的复制方法，使用传统技术
135 | */
136 | function fallbackCopyToClipboard(text, button, originalText) {
137 | try {
138 | // 创建临时textarea
139 | const textarea = document.createElement("textarea");
140 | textarea.value = text;
141 |
142 | // 确保textarea在移动设备上可见（在视口内但不可见）
143 | textarea.style.position = "fixed";
144 | textarea.style.left = "0";
145 | textarea.style.top = "0";
146 | textarea.style.opacity = "0";
147 | textarea.style.width = "100%";
148 | textarea.style.height = "100%";
149 |
150 | document.body.appendChild(textarea);
151 |
152 | // 特殊处理iOS设备
153 | if (/iPhone|iPad|iPod/.test(navigator.userAgent)) {
154 | const range = document.createRange();
155 | range.selectNodeContents(textarea);
156 | const selection = window.getSelection();
157 | selection.removeAllRanges();
158 | selection.addRange(range);
159 | textarea.setSelectionRange(0, 999999);
160 | } else {
161 | textarea.select();
162 | }
163 |
164 | const successful = document.execCommand("copy");
165 | document.body.removeChild(textarea);
166 |
167 | if (successful) {
168 | button.innerHTML = ' 已复制';
169 |
170 | // 移动端显示额外提示
171 | if (window.innerWidth < 768) {
172 | showToast("复制成功", "success");
173 | }
174 | } else {
175 | console.error("复制失败");
176 | button.innerHTML =
177 | ' 失败，请手动复制';
178 |
179 | // 移动端显示提示
180 | if (window.innerWidth < 768) {
181 | showToast("请手动长按并复制内容", "warning");
182 | }
183 | }
184 | } catch (err) {
185 | console.error("复制过程中出错:", err);
186 | button.innerHTML =
187 | ' 失败，请手动复制';
188 | }
189 |
190 | // 2秒后恢复按钮原样
191 | setTimeout(function () {
192 | button.innerHTML = originalText;
193 | }, 2000);
194 | }
195 |
196 | /**
197 | * 显示Toast提示消息（不占据页面布局）
198 | * @param {string} message - 消息内容
199 | * @param {string} type - 消息类型：success, danger, warning, info
200 | * @param {number} duration - 显示时长（毫秒），默认3000，0表示不自动关闭
201 | */
202 | function showToastNotification(message, type = "success", duration = 3000) {
203 | const container = document.getElementById("toast-container");
204 | if (!container) {
205 | console.error("Toast container not found");
206 | return;
207 | }
208 |
209 | // 创建 Toast 元素
210 | const toast = document.createElement("div");
211 | toast.className = `toast-notification toast-${type}`;
212 | toast.setAttribute("role", "alert");
213 | toast.setAttribute("aria-live", "assertive");
214 |
215 | // 根据类型设置图标
216 | let icon = "bi-info-circle";
217 | if (type === "success") {
218 | icon = "bi-check-circle";
219 | } else if (type === "danger") {
220 | icon = "bi-exclamation-circle";
221 | } else if (type === "warning") {
222 | icon = "bi-exclamation-triangle";
223 | }
224 |
225 | // 设置内容
226 | toast.innerHTML = `
227 |
228 |
229 |
232 | `;
233 |
234 | // 添加到容器
235 | container.appendChild(toast);
236 |
237 | // 关闭按钮事件
238 | const closeBtn = toast.querySelector(".toast-close");
239 | closeBtn.addEventListener("click", () => {
240 | removeToast(toast);
241 | });
242 |
243 | // 自动关闭
244 | if (duration > 0) {
245 | setTimeout(() => {
246 | removeToast(toast);
247 | }, duration);
248 | }
249 |
250 | return toast;
251 | }
252 |
253 | /**
254 | * 移除 Toast 通知
255 | */
256 | function removeToast(toast) {
257 | if (!toast || !toast.parentNode) return;
258 |
259 | toast.classList.add("toast-fade-out");
260 | setTimeout(() => {
261 | if (toast.parentNode) {
262 | toast.remove();
263 | }
264 | }, 300);
265 | }
266 |
267 | /**
268 | * HTML 转义函数
269 | */
270 | function escapeHtml(text) {
271 | const div = document.createElement("div");
272 | div.textContent = text;
273 | return div.innerHTML;
274 | }
275 |
276 | /**
277 | * 显示Toast提示消息（兼容旧版本）
278 | * @deprecated 使用 showToastNotification 代替
279 | */
280 | function showToast(message, type = "success") {
281 | showToastNotification(message, type, 2000);
282 | }
283 |
284 | /**
285 | * 初始化标签点击动画
286 | */
287 | function initTagEffects() {
288 | const tags = document.querySelectorAll(".tag, .tag-pill");
289 |
290 | tags.forEach(function (tag) {
291 | tag.addEventListener("mouseenter", function () {
292 | this.style.transform = "translateY(-5px) scale(1.05)";
293 | });
294 |
295 | tag.addEventListener("mouseleave", function () {
296 | this.style.transform = "";
297 | });
298 | });
299 | }
300 |
301 | /**
302 | * 初始化闪烁消息自动消失
303 | */
304 | function initFlashMessages() {
305 | const flashMessages = document.querySelectorAll(".alert");
306 |
307 | flashMessages.forEach(function (message) {
308 | message.classList.add("fade-in");
309 |
310 | const closeButton = message.querySelector(".btn-close");
311 | if (closeButton) {
312 | closeButton.addEventListener("click", function () {
313 | message.classList.add("fade-out");
314 |
315 | setTimeout(function () {
316 | message.remove();
317 | }, 500);
318 | });
319 | }
320 |
321 | if (!message.classList.contains("alert-danger")) {
322 | setTimeout(function () {
323 | message.classList.add("fade-out");
324 |
325 | setTimeout(function () {
326 | if (message.parentNode) {
327 | message.remove();
328 | }
329 | }, 500);
330 | }, 5000);
331 | }
332 | });
333 | }
334 |
335 | /**
336 | * 表单验证
337 | */
338 | function initFormValidation() {
339 | const forms = document.querySelectorAll(".needs-validation");
340 |
341 | forms.forEach(function (form) {
342 | form.addEventListener(
343 | "submit",
344 | function (event) {
345 | if (!form.checkValidity()) {
346 | event.preventDefault();
347 | event.stopPropagation();
348 | }
349 |
350 | form.classList.add("was-validated");
351 | },
352 | false
353 | );
354 | });
355 | }
356 |
357 | /**
358 | * 图片预览
359 | */
360 | function initImagePreview() {
361 | const fileInputs = document.querySelectorAll(
362 | 'input[type="file"][data-preview-target]'
363 | );
364 |
365 | fileInputs.forEach(function (input) {
366 | input.addEventListener("change", function () {
367 | const targetId = input.getAttribute("data-preview-target");
368 | const previewElement = document.getElementById(targetId);
369 |
370 | if (previewElement && input.files && input.files[0]) {
371 | const reader = new FileReader();
372 |
373 | reader.onload = function (e) {
374 | if (previewElement.tagName === "IMG") {
375 | previewElement.src = e.target.result;
376 | previewElement.style.display = "block";
377 | } else {
378 | previewElement.style.backgroundImage = `url(${e.target.result})`;
379 | }
380 |
381 | previewElement.classList.add("preview-loaded");
382 | };
383 |
384 | reader.readAsDataURL(input.files[0]);
385 | }
386 | });
387 | });
388 | }
389 |
390 | /**
391 | * 初始化滚动导航栏
392 | */
393 | function initScrollNavbar() {
394 | let lastScrollTop = 0;
395 | const navbar = document.querySelector(".navbar");
396 | const scrollThreshold = 100;
397 |
398 | if (navbar) {
399 | navbar.classList.add("navbar-visible");
400 |
401 | window.addEventListener(
402 | "scroll",
403 | function () {
404 | const currentScrollTop =
405 | window.pageYOffset || document.documentElement.scrollTop;
406 |
407 | if (currentScrollTop > scrollThreshold) {
408 | if (currentScrollTop > lastScrollTop) {
409 | navbar.classList.remove("navbar-visible");
410 | navbar.classList.add("navbar-hidden");
411 | } else {
412 | navbar.classList.remove("navbar-hidden");
413 | navbar.classList.add("navbar-visible");
414 | }
415 | } else {
416 | navbar.classList.remove("navbar-hidden");
417 | navbar.classList.add("navbar-visible");
418 | }
419 |
420 | setTimeout(function () {
421 | lastScrollTop = currentScrollTop;
422 | }, 100);
423 | },
424 | { passive: true }
425 | );
426 | }
427 | }
428 |
429 | /**
430 | * 页面过渡动画
431 | */
432 | function initPageTransitions() {
433 | document.querySelectorAll("a").forEach((link) => {
434 | if (
435 | link.hostname === window.location.hostname &&
436 | !link.hasAttribute("data-no-transition") &&
437 | !link.getAttribute("href").startsWith("#") &&
438 | !link.getAttribute("href").includes("javascript:")
439 | ) {
440 | link.addEventListener("click", function (e) {
441 | e.preventDefault();
442 |
443 | const targetUrl = this.getAttribute("href");
444 |
445 | document.body.classList.add("page-exit");
446 |
447 | setTimeout(() => {
448 | window.location.href = targetUrl;
449 | }, 300);
450 | });
451 | }
452 | });
453 |
454 | window.addEventListener("pageshow", function () {
455 | document.body.classList.add("page-enter");
456 | document.body.classList.remove("page-exit");
457 | });
458 | }
459 |
460 | /**
461 | * 为卡片添加进场动画
462 | */
463 | function initCardAnimations() {
464 | const cards = document.querySelectorAll(".card");
465 |
466 | if (cards.length > 0) {
467 | const observer = new IntersectionObserver(
468 | (entries) => {
469 | entries.forEach((entry) => {
470 | if (entry.isIntersecting) {
471 | entry.target.classList.add("card-visible");
472 | observer.unobserve(entry.target);
473 | }
474 | });
475 | },
476 | {
477 | threshold: 0.1,
478 | }
479 | );
480 |
481 | cards.forEach((card, index) => {
482 | card.classList.add("card-animate");
483 | card.style.animationDelay = `${index * 0.05}s`;
484 | observer.observe(card);
485 | });
486 | }
487 | }
488 |
489 | /**
490 | * 执行错开动画的元素
491 | */
492 | function initStaggeredItems() {
493 | const staggerContainers = document.querySelectorAll(".stagger-container");
494 |
495 | staggerContainers.forEach((container) => {
496 | const items = container.querySelectorAll(".stagger-item");
497 |
498 | const observer = new IntersectionObserver(
499 | (entries) => {
500 | if (entries[0].isIntersecting) {
501 | items.forEach((item, index) => {
502 | setTimeout(() => {
503 | item.classList.add("stagger-visible");
504 | }, index * 100);
505 | });
506 | observer.unobserve(container);
507 | }
508 | },
509 | {
510 | threshold: 0.1,
511 | }
512 | );
513 |
514 | observer.observe(container);
515 | });
516 | }
517 |
--------------------------------------------------------------------------------
/app/templates/base.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
9 |
10 |
14 |
15 |
16 |
101 |
271 |
102 |
270 |
103 |
110 |
111 | 104 | AI 自动填充设置 105 |
106 |107 | 配置 AI API 以启用自动生成标题、描述和标签功能 108 |
109 |
112 |
268 |
269 |