development_of_web_application_systems/main.py

import math
import random
import psutil
import pymysql
import pytz

from flask import Flask, render_template, jsonify, request, session, redirect, url_for
from datetime import datetime
from sqlalchemy.sql.ddl import CreateTable

app = Flask(__name__)
# 创建数据库连接
app.secret_key = 'SecretKey'    # 设置Secret Key

@app.route("/404")  #host:post/404:404页面展示，主要用于划分权限查看
def index_404():
    return render_template('page/404.html',)

@app.route("/logout")  #host:post/logout:
def logout():
    session.clear()  # 清除会话数据
    # session['logged_out'] = True
    return redirect(url_for('login'))

@app.route("/register")
def register():
    return render_template('page/register.html',)

@app.route("/login")
def login():
    return render_template('page/login.html',)

@app.route("/api_login", methods=['GET'])
def api_login():
    username =request.args.get('username')
    password = request.args.get('password')
    # 连接到数据库
    connection = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
    try:
        with connection.cursor() as cursor:
            # 检查用户名和密码是否正确
            sql = f"SELECT * FROM user WHERE username = '{username}' AND password = '{password}'"
            cursor.execute(sql)
            result = cursor.fetchone()

            if result:
                session['quanxian'] = result['quanxian']
                session['username'] = username
                data={'code':0,'msg':'登录成功'}
            else:
                data = {'code': 1, 'msg': '登录失败'}
    finally:
        connection.close()  # 确保数据库连接被关闭
    return jsonify(data)

@app.route("/api_register", methods=['GET'])
def api_register():
    username =request.args.get('username')
    password = request.args.get('password')
    # 连接到数据库
    connection = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
    try:
        with connection.cursor() as cursor:
            # 插入一条数据的 SQL 语句
            sql = """
                INSERT INTO user(username, password,quanxian)
                VALUES (%s, %s, %s)
                """
            # 替换 %s 为你想要插入的数据
            data = (username,password,0)
            # 执行 SQL 语句
            cursor.execute(sql, data)
            # 提交事务
            connection.commit()

            res_data = {
                'code': 0,
                'msg': '注册成功'
            }
    except:
        res_data = {
            'code': 1,
            'msg': '注册失败'
        }
    finally:
        connection.close()  # 确保数据库连接被关闭

    return jsonify(res_data)

@app.route("/")
def logins():
    return render_template('page/login.html',)

@app.route("/index_echarts")
def index_echarts():
    return render_template('index.html',)

@app.route("/warings")
def warings():
    if session['quanxian'] == 1:
        return render_template('page/warings.html')
    else:
        return render_template('page/404.html')

@app.route("/admin")
def admin():
    username = session['username']
    data={
        'username':username
    }
    return render_template('page/index.html', **data)

@app.route("/log")
def log():
    return render_template('page/table.html',)

@app.route("/user")
def user():
    if session['quanxian'] ==1:
        return render_template('page/user.html')
    else:
        return render_template('page/404.html')

@app.route("/install")
def install():
    try:
        db = pymysql.connect(host='192.168.153.165', user='yunwei',      password='123456',database='yunwei',  charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
        with db.cursor() as cursor:
            # 创建一个表的 SQL 语句
            sql = """
            CREATE TABLE IF NOT EXISTS my_table (
                ID INT AUTO_INCREMENT PRIMARY KEY,
                CPU FLOAT NOT NULL,
                neicun FLOAT NOT NULL,
                disk FLOAT NOT NULL,
                shang FLOAT NOT NULL,
                xia FLOAT NOT NULL,
                jiqihao VARCHAR(80),
                at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
            """
            user_sql = """
                  CREATE TABLE IF NOT EXISTS user (
                      ID INT AUTO_INCREMENT PRIMARY KEY,
                      username VARCHAR(80) UNIQUE NOT NULL,
                      password VARCHAR(80),
                      quanxian INT,
    
                      at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
                  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
                  """
            warings = """
            CREATE TABLE IF NOT EXISTS warings (
                ID INT AUTO_INCREMENT PRIMARY KEY,
                CPU FLOAT NOT NULL,
                neicun FLOAT NOT NULL,
                disk FLOAT NOT NULL,
                shang FLOAT NOT NULL,
                xia FLOAT NOT NULL,
                jiqihao VARCHAR(80),
                message VARCHAR(80),
                ip VARCHAR(80),
                at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
            ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
            """
            # 执行 SQL 语句
            cursor.execute(warings)
            # 执行 SQL 语句
            cursor.execute(user_sql)
            # 执行 SQL 语句
            cursor.execute(sql)
            # 提交事务
            db.commit()

    finally:
        # 关闭数据库连接
        db.close()
    return jsonify({'code':0,'msg':'数据库创建成功'})

@app.route("/api_log", methods=['GET'])
def api_log():
    # 假设每页显示10条记录
    LIMIT_PER_PAGE =int(request.args.get('limit'))
    # 假设我们要查询第3页的数据
    PAGE = int(request.args.get('page'))
    # 计算 OFFSET
    OFFSET = (PAGE - 1) * LIMIT_PER_PAGE
    # 创建数据库连接
    connection = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
    try:
        with connection.cursor() as cursor:
            # 创建一个 SQL 查询，使用 LIMIT 和 OFFSET 进行翻页
            sql = "SELECT * FROM my_table LIMIT %s OFFSET %s"
            cursor.execute(sql, (LIMIT_PER_PAGE, OFFSET))
            # 获取所有记录
            results = cursor.fetchall()
            # 创建一个 SQL 查询，用于获取表中的行数
            sql_count = "SELECT COUNT(*) FROM my_table"
            cursor.execute(sql_count)
            result_count = cursor.fetchone()
            count = result_count['COUNT(*)']
            res=[]
            for row in results:
                print(row)
                res.append({
                    'id':row['ID'],
                    'cpu':row['CPU'],
                    'disk':row['disk'],
                    'shang':row['shang'],
                    'xia':row['xia'],
                    'neicun':row['neicun'],
                    'jiqihao': row['jiqihao'],
                    'at':row['at']
                })
    finally:
        # 关闭数据库连接
        connection.close()
    data={'code':0,'msg':'','count':count,'data':res}
    return jsonify(data)

@app.route("/api_warings", methods=['GET'])
def api_warings():
    # 假设每页显示10条记录
    LIMIT_PER_PAGE =int(request.args.get('limit'))
    # 假设我们要查询第3页的数据
    PAGE = int(request.args.get('page'))
    # 计算 OFFSET
    OFFSET = (PAGE - 1) * LIMIT_PER_PAGE
    # 创建数据库连接
    connection = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
    try:
        with connection.cursor() as cursor:
            # 创建一个 SQL 查询，使用 LIMIT 和 OFFSET 进行翻页
            sql = "SELECT * FROM warings LIMIT %s OFFSET %s"
            cursor.execute(sql, (LIMIT_PER_PAGE, OFFSET))
            # 获取所有记录
            results = cursor.fetchall()
            # 创建一个 SQL 查询，用于获取表中的行数
            sql_count = "SELECT COUNT(*) FROM warings"
            cursor.execute(sql_count)
            result_count = cursor.fetchone()
            count = result_count['COUNT(*)']
            res=[]
            for row in results:

                res.append({
                    'id':row['ID'],
                    'cpu':row['CPU'],
                    'disk':row['disk'],
                    'shang':row['shang'],
                    'xia':row['xia'],
                    'neicun':row['neicun'],
                    'jiqihao': row['jiqihao'],
                    'message': row['message'],
                    'at':row['at']
                })
    finally:
        # 关闭数据库连接
        connection.close()
    data={'code':0,'msg':'','count':count,'data':res}
    return jsonify(data)

@app.route("/api_user", methods=['GET'])
def api_user():
    # 假设每页显示10条记录
    LIMIT_PER_PAGE =int(request.args.get('limit'))
    # 假设我们要查询第3页的数据
    PAGE = int(request.args.get('page'))
    # 计算 OFFSET
    OFFSET = (PAGE - 1) * LIMIT_PER_PAGE
    # 创建数据库连接
    connection = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
    try:
        with connection.cursor() as cursor:
            # 创建一个 SQL 查询，使用 LIMIT 和 OFFSET 进行翻页
            sql = "SELECT * FROM user LIMIT %s OFFSET %s"
            cursor.execute(sql, (LIMIT_PER_PAGE, OFFSET))
            # 获取所有记录
            results = cursor.fetchall()
            # 创建一个 SQL 查询，用于获取表中的行数
            sql_count = "SELECT COUNT(*) FROM user"
            cursor.execute(sql_count)
            result_count = cursor.fetchone()
            count = result_count['COUNT(*)']
            res=[]
            for row in results:
                if row['quanxian']==0:
                    quanxian='普通用户'
                else:

                    quanxian = '超级管理员'
                res.append({
                    'id':row['ID'],
                    'username':row['username'],
                    'quanxian':quanxian,

                    'at':row['at']
                })
    finally:
        # 关闭数据库连接
        connection.close()
    data={'code':0,'msg':'','count':count,'data':res}
    return jsonify(data)

@app.route("/api_msg")
def api_msg():
    total_mem,used_mem,available_memory_gb,memory_percent=neicun()
    cpu=get_cpu_percent()
    used, free,usage_percent= get_disk_usage()
    disk_data=[
        {
            'name': '已用硬盘',
            'value': used
        },
        {
            'name': '未用硬盘',
            'value': free
        }
    ]
    cpu_data=[
        {
            'name': '已用CPU',
            'value': cpu
        }, {
            'name': '未用CPU',
            'value': 100-int(cpu)
        }
    ]
    shang= random.randint(0,100)
    xia= random.randint(0,100)
    kuandai_data=[
        {
            'name': '上行',
            'value':shang
        }, {
            'name': '下行',
            'value': xia
        }
    ]
    neicun_data=[{
        'name':'已用内存',
        'value':used_mem
    },{
        'name':'未用内存',
        'value':available_memory_gb
    }]

    try:
        db = pymysql.connect(host='192.168.153.165', user='yunwei',      password='123456',database='yunwei',  charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
        with db.cursor() as cursor:
            # 插入一条数据的 SQL 语句
            sql = """
            INSERT INTO my_table(CPU, neicun, disk, shang, xia, jiqihao)
            VALUES (%s, %s, %s, %s, %s, %s)
            """
            # 替换 %s 为你想要插入的数据
            data = (int(cpu), memory_percent, usage_percent,shang, xia, '业务2号机')
            cursor.execute(sql, data)
            # 执行 SQL 语句
            if 100-int(cpu)>=90:
                sql = """
                          INSERT INTO warings(CPU, neicun, disk, shang, xia, jiqihao,message)
                          VALUES (%s, %s, %s, %s, %s, %s, %s)
                          """
                # 替换 %s 为你想要插入的数据
                data = (int(cpu), memory_percent, usage_percent, shang, xia, '业务2号机','CPU负载过高')
                cursor.execute(sql, data)
            # 提交事务
            db.commit()

        print("数据插入成功！")

    except pymysql.MySQLError as e:
        print(f"发生错误: {e}")

    finally:
        # 关闭连接
        db.close()
    data={
        'neicun':neicun_data,
        'cpu':cpu_data,
        'disk':disk_data,
        'kuandai':kuandai_data
    }
    return jsonify(data)

@app.route("/delete_username", methods=['GET'])
def delete_username():
    # 假设每页显示10条记录
    id =request.args.get('id')

    try:
        db = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
        with db.cursor() as cursor:
            # 插入一条数据的 SQL 语句
            sql = f"DELETE FROM user WHERE id = '{id}'"

            cursor.execute(sql)
            db.commit()
        data={
            'code':0,
            'msg':'用户删除成功'
        }

    except pymysql.MySQLError as e:
        print(f"发生错误: {e}")
        data = {
            'code': 1,
            'msg': f'发生错误: {e}'
        }

    finally:
        # 关闭连接
        db.close()
    return jsonify(data)

@app.route("/api_Superadmin", methods=['GET'])
def api_Superadmin():
    # 假设每页显示10条记录
    id =request.args.get('id')
    try:
        db = pymysql.connect(host='192.168.153.165', user='yunwei', password='123456', database='yunwei', charset='utf8mb4',cursorclass=pymysql.cursors.DictCursor)
        with db.cursor() as cursor:
            # 插入一条数据的 SQL 语句
            sql = f"UPDATE user SET quanxian = 1 WHERE id = '{id}'"
            cursor.execute(sql)
            db.commit()
        data={
            'code':0,
            'msg':'用户设置成功'
        }

    except pymysql.MySQLError as e:
        data = {
            'code': 1,
            'msg': f'发生错误: {e}'
        }
    finally:
        # 关闭连接
        db.close()
    return jsonify(data)

def neicun():
    # 获取内存信息
    mem = psutil.virtual_memory()
    # 将字节转换为GB
    total_memory_gb = mem.total / (1024 ** 3)
    used_memory_gb = mem.used / (1024 ** 3)
    available_memory_gb = mem.available / (1024 ** 3)  # 空闲内存
    # 计算空间占比（已用内存占总内存的百分比）
    memory_percent = (mem.used / mem.total) * 100
    return total_memory_gb,used_memory_gb,available_memory_gb,memory_percent
def get_cpu_percent(interval=1):
    return psutil.cpu_percent(interval=interval)
def get_disk_usage(disk_path='/'):
    disk_usage = psutil.disk_usage(disk_path)
    used = disk_usage.used  # 已用空间
    free = disk_usage.free  # 未用空间
    total = disk_usage.total

    # 计算已用空间与总空间的比例（以百分比表示）
    usage_percent = (used / total) * 100
    return used, free,usage_percent

if __name__ == '__main__':
    app.run(debug=True, host='127.0.0.1', port='7000')