金字招牌

1
┌──────────────────────────────────────────────────────────────────┐
2
│                     前端(HTML5/CSS3/JS)                          │
3
│               Material You (M3) 暗色主题 + ECharts图表            │
4
└───────────────────────────────┬──────────────────────────────────┘
5
                                │ HTTP REST API
6
┌───────────────────────────────▼───────────────────────────────────┐
7
│                        Python Flask 后端                          │
8
│  用户认证  成绩管理  活动管理  留言管理  座位编排  AI智能分析        │
9
└───────────┬───────────────┬───────────────┬──────────────────────┘
10
            │               │               │
11
            ↓               ↓               ↓
12
┌───────────────────┐ ┌─────────────┐ ┌──────────────┐
13
│  C语言算法 (DLL)   │ │ 硅基流动 AI  │ │    MySQL     │
14
│ • 基础统计 (6)    │ │ OpenAI兼容  │ │ 13个数据表    │
15
│ • 成绩分析 (5)    │ │ 多模型选择   │ │ 组织架构     │
16
│ • GPA计算 (2)     │ │ 智能分析    │ │ 成绩管理     │
17
│ • 排序查找 (5)    │ └─────────────┘ │ 活动留言     │
18
│ • 趋势分析 (4)    │  ctypes调用     │ 座位编排     │
19
│ • 高级统计 (5)    │  失败自动回退   └──────────────┘
20
│ • 座位编排 (6)    │  Python实现
21
│   合计38个函数     │
22
└───────────────────┘

1
#include <stdio.h>
2
#include <math.h>
3
#include <stdlib.h>
4

5
#define MAX_STUDENTS 100
6
#define MAX_COURSES 10
7

8
/* 求和：遍历数组累加 */
9
double __declspec(dllexport) get_sum(double arr[], int n) {
10
    double sum = 0;
11
    for (int i = 0; i < n; i++) {
12
        sum = sum + arr[i];
13
    }
14
    return sum;
15
}
16

17
/* 平均分：sum / n，注意 n=0 时返回 0 避免除零 */
18
double __declspec(dllexport) calc_average(double arr[], int n) {
19
    if (n == 0) return 0;
20
    double sum = get_sum(arr, n);
21
    return sum / n;
22
}
23

24
/* 方差：Σ(xi - avg)² / n */
25
double __declspec(dllexport) calc_variance(double arr[], int n) {
26
    if (n == 0) return 0;
27
    double avg = calc_average(arr, n);
28
    double sum_squared_diff = 0;
29
    for (int i = 0; i < n; i++) {
30
        double diff = arr[i] - avg;
31
        sum_squared_diff = sum_squared_diff + diff * diff;
32
    }
33
    return sum_squared_diff / n;
34
}
35

36
/* 标准差：方差开根号 */
37
double __declspec(dllexport) calc_stddev(double arr[], int n) {
38
    double variance = calc_variance(arr, n);
39
    return sqrt(variance);
40
}
41

42
/* 及格率：score >= 60 的人数占比 × 100 */
43
double __declspec(dllexport) calc_pass_rate(double arr[], int n) {
44
    if (n == 0) return 0;
45
    int pass_count = 0;
46
    for (int i = 0; i < n; i++) {
47
        if (arr[i] >= 60) {
48
            pass_count = pass_count + 1;
49
        }
50
    }
51
    return (double)pass_count / n * 100;
52
}
53

54
/* 优秀率：score >= 90 的人数占比 × 100 */
55
double __declspec(dllexport) calc_excellent_rate(double arr[], int n) {
56
    if (n == 0) return 0;
57
    int excellent_count = 0;
58
    for (int i = 0; i < n; i++) {
59
        if (arr[i] >= 90) {
60
            excellent_count = excellent_count + 1;
61
        }
62
    }
63
    return (double)excellent_count / n * 100;
64
}
65

66
/* 成绩分段统计：结果写入 level[5]
67
   level[0]=不及格(<60), level[1]=及格(60-69),
68
   level[2]=中等(70-79), level[3]=良好(80-89), level[4]=优秀(>=90) */
69
void __declspec(dllexport) calc_level_distribution(double arr[], int n, int level[]) {
70
    for (int i = 0; i < 5; i++) {
71
        level[i] = 0;
72
    }
73
    for (int i = 0; i < n; i++) {
74
        if (arr[i] < 60)        level[0] = level[0] + 1;
75
        else if (arr[i] < 70)   level[1] = level[1] + 1;
76
        else if (arr[i] < 80)   level[2] = level[2] + 1;
77
        else if (arr[i] < 90)   level[3] = level[3] + 1;
78
        else                    level[4] = level[4] + 1;
79
    }
80
}

1
/* 分数转绩点：90→4.0, 80→3.0, 70→2.0, 60→1.0, 否则 0 */
2
double __declspec(dllexport) score_to_point(double score) {
3
    if (score >= 90) return 4.0;
4
    if (score >= 80) return 3.0;
5
    if (score >= 70) return 2.0;
6
    if (score >= 60) return 1.0;
7
    return 0.0;
8
}
9

10
/* GPA = Σ(绩点 × 学分) / Σ(学分) */
11
double __declspec(dllexport) calc_gpa(double scores[], double credits[], int n) {
12
    double total_points = 0;
13
    double total_credits = 0;
14
    for (int i = 0; i < n; i++) {
15
        double point = score_to_point(scores[i]);
16
        total_points = total_points + point * credits[i];
17
        total_credits = total_credits + credits[i];
18
    }
19
    if (total_credits == 0) return 0;
20
    return total_points / total_credits;
21
}
22

23
/* 冒泡排序（降序）：相邻元素比较，小的后移 */
24
void __declspec(dllexport) bubble_sort_desc(double arr[], int n) {
25
    for (int i = 0; i < n - 1; i++) {
26
        for (int j = 0; j < n - 1 - i; j++) {
27
            if (arr[j] < arr[j + 1]) {
28
                double temp = arr[j];
29
                arr[j] = arr[j + 1];
30
                arr[j + 1] = temp;
31
            }
32
        }
33
    }
34
}
35

36
/* 选择排序（降序）：每轮选最大值放到已排序区末尾 */
37
void __declspec(dllexport) selection_sort_desc(double arr[], int n) {
38
    for (int i = 0; i < n - 1; i++) {
39
        int max_index = i;
40
        for (int j = i + 1; j < n; j++) {
41
            if (arr[j] > arr[max_index]) {
42
                max_index = j;
43
            }
44
        }
45
        double temp = arr[i];
46
        arr[i] = arr[max_index];
47
        arr[max_index] = temp;
48
    }
49
}

1
/**
2
 * 计算中位数
3
 * 先用 malloc 复制数组避免修改原数据，再选择排序后取中间值
4
 * 奇数个取中间，偶数个取中间两个的平均
5
 */
6
double __declspec(dllexport) calc_median(double arr[], int n) {
7
    if (n == 0) return 0;
8
    /* 复制数组，避免修改原数据 */
9
    double *tmp = (double *)malloc(n * sizeof(double));
10
    for (int i = 0; i < n; i++) {
11
        tmp[i] = arr[i];
12
    }
13
    /* 选择排序升序 */
14
    for (int i = 0; i < n - 1; i++) {
15
        int min_idx = i;
16
        for (int j = i + 1; j < n; j++) {
17
            if (tmp[j] < tmp[min_idx]) {
18
                min_idx = j;
19
            }
20
        }
21
        double t = tmp[i];
22
        tmp[i] = tmp[min_idx];
23
        tmp[min_idx] = t;
24
    }
25
    double result;
26
    if (n % 2 == 1) {
27
        result = tmp[n / 2];
28
    } else {
29
        result = (tmp[n / 2 - 1] + tmp[n / 2]) / 2.0;
30
    }
31
    free(tmp);   /* 别忘了释放！ */
32
    return result;
33
}
34

35
/**
36
 * 计算众数（出现次数最多的值）
37
 * 若多个值频次相同，返回最小的那个
38
 */
39
double __declspec(dllexport) calc_mode(double arr[], int n) {
40
    if (n == 0) return 0;
41
    double mode_val = arr[0];
42
    int max_count = 1;
43
    for (int i = 0; i < n; i++) {
44
        int count = 1;
45
        for (int j = i + 1; j < n; j++) {
46
            if (arr[j] == arr[i]) {
47
                count++;
48
            }
49
        }
50
        if (count > max_count || (count == max_count && arr[i] < mode_val)) {
51
            max_count = count;
52
            mode_val = arr[i];
53
        }
54
    }
55
    return mode_val;
56
}
57

58
/**
59
 * 皮尔逊相关系数：衡量两组数据（如两次考试）的线性相关程度
60
 * 返回 [-1, 1]，1=完全正相关，-1=完全负相关，0=无线性相关
61
 * 公式：cov(x,y) / (σx × σy)
62
 */
63
double __declspec(dllexport) calc_correlation(double x[], double y[], int n) {
64
    if (n < 2) return 0;
65
    double sum_x = 0, sum_y = 0;
66
    for (int i = 0; i < n; i++) {
67
        sum_x += x[i];
68
        sum_y += y[i];
69
    }
70
    double mean_x = sum_x / n;
71
    double mean_y = sum_y / n;
72
    double cov = 0, var_x = 0, var_y = 0;
73
    for (int i = 0; i < n; i++) {
74
        double dx = x[i] - mean_x;
75
        double dy = y[i] - mean_y;
76
        cov += dx * dy;
77
        var_x += dx * dx;
78
        var_y += dy * dy;
79
    }
80
    if (var_x == 0 || var_y == 0) return 0;
81
    return cov / (sqrt(var_x) * sqrt(var_y));
82
}

1
#define MAX_SEAT_ROWS 30
2
#define MAX_SEAT_COLS 30
3
#define MAX_SEAT_STUDENTS 500
4

5
/* 学生综合信息结构 */
6
typedef struct {
7
    int student_id;       /* 学号 */
8
    double composite;     /* 综合评分（此处即成绩均分） */
9
} SeatStudent;
10

11
/* 座位优先级结构：priority 越小越优先分配 */
12
typedef struct {
13
    double priority;
14
    int row;
15
    int col;
16
} SeatPriority;
17

18
/* 全局变量：座位结果与学生数组（DLL 跨函数共享） */
19
static SeatResult g_seat_result;
20
static SeatStudent g_students[MAX_SEAT_STUDENTS];
21

22
/**
23
 * 智能排座算法
24
 * 排座策略：
25
 * 1. 按成绩升序排序，差生优先安排好座位
26
 * 2. 交错排列：偶数位放低分组，奇数位放高分组
27
 *    如 60分、80分、55分、75分... 避免 60 和 55 挨着
28
 * 3. 计算座位优先级：行号 + 列偏移/列数*0.5
29
 *    行号越小越靠前，列越靠中间偏移越小，前排中间 priority 最小
30
 * 4. 验证邻座搭配：发现两个不及格(<60)相邻时，
31
 *    在附近找一个及格学生交换，并校验交换后不产生新的双差邻座
32
 */
33
int __declspec(dllexport) arrange_seats(
34
    int student_ids[], double composites[], int heights[], int visions[],
35
    int n, int rows, int cols)
36
{
37
    if (n <= 0 || rows <= 0 || cols <= 0 || n > MAX_SEAT_STUDENTS ||
38
        rows > MAX_SEAT_ROWS || cols > MAX_SEAT_COLS)
39
        return -1;
40

41
    /* 初始化座位图为 -1（空位） */
42
    for (int r = 0; r < rows; r++)
43
        for (int c = 0; c < cols; c++)
44
            g_seat_result.seat_map[r][c] = -1;
45

46
    /* 填充学生数据 */
47
    for (int i = 0; i < n; i++) {
48
        g_students[i].student_id = student_ids[i];
49
        g_students[i].composite = composites[i];
50
    }
51

52
    /* 按成绩升序排序（低分在前），差生优先安排好座位 */
53
    for (int i = 0; i < n - 1; i++) {
54
        for (int j = 0; j < n - 1 - i; j++) {
55
            if (g_students[j].composite > g_students[j+1].composite) {
56
                SeatStudent tmp = g_students[j];
57
                g_students[j] = g_students[j+1];
58
                g_students[j+1] = tmp;
59
            }
60
        }
61
    }
62

63
    /* 交错排列：偶数位放低分组(0..mid-1)，奇数位放高分组(mid..n-1) */
64
    int mid = n / 2;
65
    int interleaved[MAX_SEAT_STUDENTS];
66
    int weak_idx = 0, strong_idx = mid;
67
    int count = 0;
68
    for (int i = 0; i < n; i++) {
69
        if (i % 2 == 0) {
70
            if (weak_idx < mid) interleaved[count++] = weak_idx++;
71
            else                interleaved[count++] = strong_idx++;
72
        } else {
73
            if (strong_idx < n) interleaved[count++] = strong_idx++;
74
            else                interleaved[count++] = weak_idx++;
75
        }
76
    }
77

78
    /* 计算所有座位的优先级（前排中间最小） */
79
    SeatPriority seat_order[MAX_SEAT_ROWS * MAX_SEAT_COLS];
80
    double center_col = (cols - 1) / 2.0;
81
    int seat_count = 0;
82
    for (int r = 0; r < rows; r++) {
83
        for (int c = 0; c < cols; c++) {
84
            seat_order[seat_count].priority = r + fabs(c - center_col) / (cols * 2.0);
85
            seat_order[seat_count].row = r;
86
            seat_order[seat_count].col = c;
87
            seat_count++;
88
        }
89
    }
90
    /* 按优先级升序排序：小值优先 = 前排中间优先 */
91
    qsort(seat_order, seat_count, sizeof(SeatPriority), cmp_seat_priority);
92

93
    /* 按座位优先级分配交错排列后的学生 */
94
    for (int i = 0; i < seat_count && i < count; i++) {
95
        int r = seat_order[i].row;
96
        int c = seat_order[i].col;
97
        g_seat_result.seat_map[r][c] = interleaved[i];
98
    }
99

100
    /* 修正阶段：确保没有两个不及格(<60)的学生上下左右相邻
101
       若发现，则找一个及格学生交换位置，并校验不产生新的双差邻座 */
102
    int changed = 1;
103
    int max_rounds = n * 2;   /* 防止无限循环 */
104
    while (changed && max_rounds-- > 0) {
105
        changed = 0;
106
        for (int r = 0; r < rows; r++) {
107
            for (int c = 0; c < cols; c++) {
108
                int idx1 = g_seat_result.seat_map[r][c];
109
                if (idx1 < 0 || idx1 >= n) continue;
110
                if (g_students[idx1].composite >= 60.0) continue;
111

112
                /* 检查右邻座和下邻座是否也是不及格，若是则尝试交换 */
113
                /* ...（完整代码见源文件，使用四方向偏移数组 dr/dc 校验 safe） */
114
            }
115
        }
116
    }
117

118
    return 0;
119
}
120

121
/* 比较函数：座位优先级升序（供 qsort 使用） */
122
static int cmp_seat_priority(const void *a, const void *b) {
123
    double diff = ((SeatPriority*)a)->priority - ((SeatPriority*)b)->priority;
124
    if (diff > 0) return 1;
125
    if (diff < 0) return -1;
126
    return 0;
127
}
128

129
/**
130
 * 计算座位均衡度（0-100，越高越均衡）
131
 * 算法：计算每行平均综合评分，再求各行均分的标准差
132
 * 标准差越小越均衡，映射为 balance = 100 - stddev × 5
133
 */
134
double __declspec(dllexport) calc_seat_balance() {
135
    if (g_seat_result.student_count == 0) return 0;
136
    double row_avgs[MAX_SEAT_ROWS];
137
    int valid_rows = 0;
138
    for (int r = 0; r < g_seat_result.rows; r++) {
139
        double sum = 0;
140
        int count = 0;
141
        for (int c = 0; c < g_seat_result.cols; c++) {
142
            int idx = g_seat_result.seat_map[r][c];
143
            if (idx >= 0 && idx < g_seat_result.student_count) {
144
                sum += g_students[idx].composite;
145
                count++;
146
            }
147
        }
148
        if (count > 0) row_avgs[valid_rows++] = sum / count;
149
    }
150
    if (valid_rows < 2) return 100.0;
151

152
    double total_avg = 0;
153
    for (int i = 0; i < valid_rows; i++) total_avg += row_avgs[i];
154
    total_avg /= valid_rows;
155

156
    double variance = 0;
157
    for (int i = 0; i < valid_rows; i++) {
158
        double diff = row_avgs[i] - total_avg;
159
        variance += diff * diff;
160
    }
161
    variance /= valid_rows;
162
    double stddev = sqrt(variance);
163

164
    double balance = 100.0 - stddev * 5.0;
165
    if (balance < 0) balance = 0;
166
    if (balance > 100) balance = 100;
167
    return balance;
168
}

1
import os
2
import sys
3
from dotenv import load_dotenv
4

5
# 路径处理：支持 PyInstaller 打包后的路径
6
if getattr(sys, 'frozen', False):
7
    # 打包后：_MEIPASS 是 PyInstaller 解包临时目录
8
    MEIPASS = sys._MEIPASS
9
    BASE_DIR = os.path.dirname(sys.executable)          # exe 所在目录
10
    INTERNAL_DIR = os.path.join(BASE_DIR, '_internal')  # 资源目录
11
    PROJECT_ROOT = INTERNAL_DIR
12
else:
13
    # 开发模式
14
    MEIPASS = None
15
    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
16
    INTERNAL_DIR = BASE_DIR
17
    PROJECT_ROOT = os.path.dirname(BASE_DIR)
18

19
# 加载 .env：打包模式优先从 exe 目录加载，方便用户配置
20
if getattr(sys, 'frozen', False):
21
    env_path = os.path.join(BASE_DIR, '.env')
22
    if not os.path.exists(env_path):
23
        env_path = os.path.join(INTERNAL_DIR, 'backend', '.env')
24
else:
25
    env_path = os.path.join(PROJECT_ROOT, 'backend', '.env')
26
if os.path.exists(env_path):
27
    load_dotenv(env_path, override=True)
28

29
# MySQL 配置（从环境变量读取）
30
MYSQL_HOST = os.environ.get('MYSQL_HOST', 'localhost')
31
MYSQL_PORT = int(os.environ.get('MYSQL_PORT', '3306'))
32
MYSQL_USER = os.environ.get('MYSQL_USER', 'root')
33
MYSQL_PASSWORD = os.environ.get('MYSQL_PASSWORD', '')
34
MYSQL_DATABASE = os.environ.get('MYSQL_DATABASE', 'bigwork')
35

36
# C 算法 DLL 路径
37
if MEIPASS:
38
    C_ALGORITHM_DLL = os.path.join(MEIPASS, 'c_algorithm', 'score_analysis.dll')
39
else:
40
    C_ALGORITHM_DLL = os.path.join(PROJECT_ROOT, 'c_algorithm', 'score_analysis.dll')
41

42
# 大模型配置
43
SILICONFLOW_API_KEY = os.environ.get('SILICONFLOW_API_KEY', '')
44
SILICONFLOW_API_URL = os.environ.get('SILICONFLOW_API_URL',
45
                                     'https://api.siliconflow.cn/v1/chat/completions')
46
SILICONFLOW_MODEL = os.environ.get('SILICONFLOW_MODEL', 'Qwen/Q2.5-7B-Instruct')
47

48
def get_frontend_path():
49
    """获取前端文件目录路径（供 app.py 调用）"""
50
    if MEIPASS:
51
        return os.path.join(MEIPASS, 'frontend')
52
    return os.path.join(PROJECT_ROOT, 'frontend')

1
import pymysql
2
from dbutils.pooled_db import PooledDB
3

4
_db_pool = None
5

6
def _get_pool():
7
    global _db_pool
8
    if _db_pool is None:
9
        _db_pool = PooledDB(
10
            creator=pymysql,
11
            maxconnections=10,    # 最大连接数
12
            mincached=2,          # 初始空闲连接
13
            maxcached=5,          # 最大空闲连接
14
            blocking=True,
15
            host=MYSQL_HOST, port=MYSQL_PORT,
16
            user=MYSQL_USER, password=MYSQL_PASSWORD,
17
            database=MYSQL_DATABASE,
18
            charset='utf8mb4',
19
            cursorclass=pymysql.cursors.DictCursor  # 返回字典形式结果
20
        )
21
    return _db_pool
22

23
def get_db_connection():
24
    """从连接池获取数据库连接"""
25
    try:
26
        return _get_pool().connection()
27
    except Exception as e:
28
        print(f"数据库连接失败: {e}")
29
        return None

1
import ctypes
2

3
# 加载 C 算法 DLL
4
c_lib = None
5
try:
6
    dll_path = C_ALGORITHM_DLL
7
    if os.path.exists(dll_path):
8
        c_lib = ctypes.CDLL(dll_path)
9
        print(f"C算法模块加载成功: {dll_path}")
10
    else:
11
        print(f"C算法DLL未找到: {dll_path}，将使用Python回退实现")
12
except Exception as e:
13
    print(f"C算法模块加载失败: {e}，将使用Python回退实现")
14

15

16
def c_calc_average(scores):
17
    """调用C算法计算平均分，DLL不可用时回退到Python实现"""
18
    if c_lib:
19
        n = len(scores)
20
        arr = (ctypes.c_double * n)(*scores)   # Python list → C double[]
21
        return c_lib.calc_average(arr, n)
22
    return sum(scores) / len(scores) if scores else 0
23

24

25
def c_calc_level_distribution(scores):
26
    """调用C算法计算分段分布
27
    注意：C函数通过 int level[] 出参返回，需用 ctypes 创建数组接收"""
28
    if c_lib:
29
        n = len(scores)
30
        arr = (ctypes.c_double * n)(*scores)
31
        level = (ctypes.c_int * 5)()           # 出参：5 段计数
32
        c_lib.calc_level_distribution(arr, n, level)
33
        return [level[i] for i in range(5)]
34
    # Python 回退实现
35
    dist = [0, 0, 0, 0, 0]
36
    for s in scores:
37
        if s < 60:       dist[0] += 1
38
        elif s < 70:     dist[1] += 1
39
        elif s < 80:     dist[2] += 1
40
        elif s < 90:     dist[3] += 1
41
        else:            dist[4] += 1
42
    return dist
43

44

45
def c_calc_gpa(scores, credits):
46
    """GPA 计算需要同时传入成绩数组和学分数组"""
47
    if c_lib and len(scores) == len(credits):
48
        n = len(scores)
49
        s_arr = (ctypes.c_double * n)(*scores)
50
        c_arr = (ctypes.c_double * n)(*credits)
51
        return c_lib.calc_gpa(s_arr, c_arr, n)
52
    if not scores or not credits:
53
        return 0
54
    total_points = sum(
55
        (4.0 if s >= 90 else 3.0 if s >= 80 else 2.0 if s >= 70 else 1.0 if s >= 60 else 0.0) * c
56
        for s, c in zip(scores, credits)
57
    )
58
    total_credits = sum(credits)
59
    return total_points / total_credits if total_credits else 0

1
import hashlib, os
2

3
def hash_password(password, salt=None):
4
    """密码哈希 - SHA256 + 随机盐值，格式：salt$hash"""
5
    if salt is None:
6
        salt = os.urandom(16).hex()
7
    hashed = hashlib.sha256((salt + password).encode()).hexdigest()
8
    return f"{salt}${hashed}"
9

10
def verify_password(password, stored_hash):
11
    """验证密码 - 支持哈希验证和明文兼容（旧数据验证后自动升级）"""
12
    if '$' in stored_hash:
13
        salt, hashed = stored_hash.split('$', 1)
14
        check_hash = hashlib.sha256((salt + password).encode()).hexdigest()
15
        return check_hash == hashed
16
    else:
17
        # 明文密码（兼容旧数据）
18
        return stored_hash == password
19

20
@app.route('/api/login', methods=['POST'])
21
def login():
22
    """用户登录"""
23
    try:
24
        data = request.get_json()
25
        username = data.get('username')
26
        password = data.get('password')
27
        if not username or not password:
28
            return error_response('请提供用户名和密码')
29

30
        conn = get_db_connection()
31
        if not conn:
32
            return error_response('数据库连接失败', 500)
33
        try:
34
            with conn.cursor() as cursor:
35
                cursor.execute('SELECT * FROM users WHERE username = %s', (username,))
36
                user = cursor.fetchone()
37
                if not user:
38
                    return error_response('用户名不存在')
39
                if not verify_password(password, user['password']):
40
                    return error_response('密码错误')
41

42
                # 明文密码自动升级为哈希
43
                if '$' not in user['password']:
44
                    cursor.execute(
45
                        'UPDATE users SET password = %s WHERE id = %s',
46
                        (hash_password(password), user['id'])
47
                    )
48
                    conn.commit()
49

50
                # 设置会话
51
                session['user_id'] = user['id']
52
                session['username'] = user['username']
53
                session['role_level'] = user['role_level'] if user['role_level'] is not None else 6
54
                session['user'] = {
55
                    'id': user['id'],
56
                    'username': user['username'],
57
                    'name': user['name'],
58
                    'role_level': user['role_level'],
59
                    'school_id': user.get('school_id'),
60
                    'class_id': user.get('class_id'),
61
                    'small_class_id': user.get('small_class_id'),
62
                    'group_unit_id': user.get('group_unit_id'),
63
                }
64
                return success_response({
65
                    'id': user['id'],
66
                    'username': user['username'],
67
                    'name': user['name'],
68
                    'role_level': user['role_level'],
69
                }, '登录成功')
70
        finally:
71
            conn.close()
72
    except Exception as e:
73
        return error_response(f'登录失败: {str(e)}', 500)

1
@app.route('/api/analyze/course/<int:course_id>', methods=['GET'])
2
def analyze_course(course_id):
3
    """使用C语言算法分析指定课程的成绩（只分析下级学生）"""
4
    subordinate_ids, err = get_subordinate_student_ids()
5
    if err:
6
        return err
7

8
    conn = get_db_connection()
9
    if not conn:
10
        return error_response('数据库连接失败', 500)
11
    try:
12
        with conn.cursor() as cursor:
13
            cursor.execute('SELECT * FROM courses WHERE id = %s', (course_id,))
14
            course = cursor.fetchone()
15
            if not course:
16
                return error_response('课程不存在')
17

18
            # 仅查询当前用户下级学生的成绩
19
            placeholders = ','.join(['%s'] * len(subordinate_ids))
20
            cursor.execute(f'''
21
                SELECT s.score, u.name as student_name, u.id as student_id
22
                FROM scores s
23
                JOIN users u ON s.student_id = u.id
24
                WHERE s.course_id = %s AND s.student_id IN ({placeholders})
25
                ORDER BY s.score DESC
26
            ''', [course_id] + subordinate_ids)
27
            score_records = cursor.fetchall()
28

29
            if not score_records:
30
                return success_response({'course': course['name'], 'message': '该课程暂无成绩数据'})
31

32
            scores = [float(r['score']) for r in score_records]
33

34
            # 调用 C 算法进行统计分析
35
            avg = c_calc_average(scores)
36
            variance = c_calc_variance(scores)
37
            stddev = c_calc_stddev(scores)
38
            max_score = c_find_max(scores)
39
            min_score = c_find_min(scores)
40
            median = c_calc_median(scores)
41
            mode_score = c_calc_mode(scores)
42
            pass_rate = c_calc_pass_rate(scores)
43
            excellent_rate = c_calc_excellent_rate(scores)
44
            level_dist = c_calc_level_distribution(scores)
45
            sorted_scores = c_bubble_sort_desc(scores)
46
            warning_count = c_warning_report(scores, 60)
47
            score_range = c_calc_range(scores)
48
            cv = c_calc_cv(scores)
49

50
            return success_response({
51
                'course': course['name'],
52
                'course_id': course_id,
53
                'student_count': len(scores),
54
                'statistics': {
55
                    'average': round(avg, 2),
56
                    'variance': round(variance, 2),
57
                    'stddev': round(stddev, 2),
58
                    'max': max_score, 'min': min_score,
59
                    'median': round(median, 2),
60
                    'mode': mode_score,
61
                    'range': round(score_range, 2),
62
                    'cv': round(cv, 2),
63
                    'pass_rate': round(pass_rate, 2),
64
                    'excellent_rate': round(excellent_rate, 2),
65
                    'warning_count': warning_count
66
                },
67
                'level_distribution': {
68
                    'fail': level_dist[0], 'pass': level_dist[1],
69
                    'medium': level_dist[2], 'good': level_dist[3],
70
                    'excellent': level_dist[4]
71
                },
72
                'sorted_scores': sorted_scores,
73
                'c_algorithm_loaded': c_lib is not None
74
            })
75
    finally:
76
        conn.close()

1
@app.route('/api/analyze/ai', methods=['POST'])
2
def ai_analyze():
3
    """使用大模型对成绩数据进行智能分析，支持多轮对话"""
4
    data = request.get_json()
5
    query = data.get('query', '')
6
    context = data.get('context', '')
7
    provider = data.get('provider', AI_PROVIDER)
8
    sf_model = data.get('siliconflow_model', '') or SILICONFLOW_MODEL
9
    conversation_id = data.get('conversation_id', '')   # Dify 多轮对话 ID
10
    history = data.get('history', [])                    # 硅基流动对话历史
11

12
    if not query:
13
        return error_response('请提供分析问题')
14

15
    conn = get_db_connection()
16
    if not conn:
17
        return error_response('数据库连接失败', 500)
18
    try:
19
        with conn.cursor() as cursor:
20
            # 课程统计摘要
21
            cursor.execute('''
22
                SELECT c.name as course_name,
23
                       COUNT(*) as student_count,
24
                       ROUND(AVG(s.score), 1) as avg_score,
25
                       ROUND(MAX(s.score), 1) as max_score,
26
                       ROUND(MIN(s.score), 1) as min_score,
27
                       ROUND(SUM(CASE WHEN s.score >= 60 THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as pass_rate,
28
                       ROUND(SUM(CASE WHEN s.score >= 90 THEN 1 ELSE 0 END) * 100.0 / COUNT(*), 1) as excellent_rate
29
                FROM scores s JOIN courses c ON s.course_id = c.id
30
                GROUP BY c.id, c.name ORDER BY c.name
31
            ''')
32
            course_stats = cursor.fetchall()
33
            # ...学员排名、成绩分布查询省略
34
    finally:
35
        conn.close()
36

37
    # 构建详细的分析上下文喂给大模型
38
    course_details = '\n'.join([
39
        f"  - {c['course_name']}: 平均分{c['avg_score']}, 最高{c['max_score']}, "
40
        f"最低{c['min_score']}, 及格率{c['pass_rate']}%, 优秀率{c['excellent_rate']}%, "
41
        f"共{c['student_count']}人"
42
        for c in course_stats
43
    ])
44
    data_context = f"""成绩数据详细摘要：
45

46
【课程统计】
47
{course_details}
48

49
{context}"""
50

51
    # 前端传入的 Key 优先于服务器配置
52
    sf_key = data.get('siliconflow_key', '') or SILICONFLOW_API_KEY
53
    dify_key = data.get('dify_key', '') or DIFY_API_KEY
54

55
    if provider == 'dify' and dify_key:
56
        return _call_dify(query, data_context, dify_key, conversation_id)
57
    elif provider == 'siliconflow' and sf_key:
58
        return _call_siliconflow(query, data_context, sf_key, sf_model, history)
59
    else:
60
        return success_response({
61
            'answer': f'基于当前数据分析：\n\n{data_context}\n\n提示：请在设置中输入 API Key 后可获取AI智能分析。',
62
            'source': 'local',
63
            'data_context': data_context
64
        })