Projeto de graduação em Python | design do curso | sistema de gestão do desempenho do aluno baseado em Python+Django

Página inicial do autor: Bússola de Programação

Sobre o autor: Criador de alta qualidade no campo Java, especialista em blogs CSDN, autor convidado de Nuggets, muitos anos de experiência em design de arquitetos, palestrante residente na Tencent Classroom

Conteúdo principal: Projeto Java, design de graduação, modelo de currículo, materiais didáticos, banco de perguntas para entrevistas, assistência técnica mútua

Favoritos, curtidas, não se perca, é bom seguir o autor

Obtenha o código-fonte no final do artigo 

Número do item: BS-Python-006

1. Introdução ambiental

Localidade: Python3.7

Banco de dados: Mysql: mysql5.7

Ferramentas de desenvolvimento: IDEA ou outras

Tecnologia de desenvolvimento: framework Django, front-end usando Layui+html

2. Introdução do projeto

Este projeto é desenvolvido e implementado com base na linguagem Python, utilizando o framework Django WEB para desenvolvimento, e o front end utiliza Layui+HTML para o desenvolvimento da página. Fornece códigos de verificação de login, relatórios estatísticos gráficos e funções básicas de importação e exportação de dados .

As funções do usuário do sistema podem ser personalizadas de forma flexível. Atualmente, existem administradores, diretores e usuários comuns. Você pode personalizar as funções e permissões de acordo com suas necessidades. As permissões do sistema são divididas em nível de menu e nível de botão. O controle é muito detalhado e completo. Controle a adição, exclusão, modificação e operações de consulta de determinados dados, conforme necessário, e conceda as permissões correspondentes aos usuários correspondentes, conforme necessário.

Os principais módulos funcionais do sistema incluem:

Gerenciamento de usuários: operações completas como adicionar, consultar, excluir e exportar informações do usuário.

Gerenciamento de função: operações completas, como adicionar, consultar, editar, excluir e exportar informações de função. Conceda diferentes funções de permissão para funções.

Gerenciamento de direitos: operações completas como adicionar, consultar e excluir, exportar e habilitar informações de direitos.

Gerenciamento de log: principalmente para visualizar e excluir logs de operação do usuário.

Gestão escolar: conclua a operação de adição, consulta e exclusão de informações escolares.

Gerenciamento de notas: conclua as operações de adição, consulta e exclusão de informações de notas.

Gerenciamento de turmas: conclua a adição, consulta e exclusão de informações de turmas.

Gerenciamento do curso: conclua a operação de adicionar, consultar e excluir informações do curso.

Gerenciamento de alunos: conclua a adição, consulta e exclusão de informações do aluno e pode realizar importação e exportação em lote.

Nota de entrada: notas de registro para cada aluno.

Resultados da aula: Informe-se e conte o número de referências e o número de alunos em cada série em cada escola, turma e disciplina.

Notas dos alunos: gerencie e importe dados sobre as informações de notas de todos os alunos.

Estatísticas de dados: conclua estatísticas de dados relevantes por meio de relatórios gráficos Echart.

Modificação de dados pessoais: Conclua a operação de modificação de dados pessoais e senha.

Três, exibição do sistema

Login de usuário:

 

Página inicial de gerenciamento de plano de fundo:

 

Gerenciamento de usuários:

 

Gerenciamento de papéis:

atribuir permissões:

gerenciamento de autoridade

gerenciamento de registros

gestão escolar

Gestão de Notas

gerenciamento de classe

gerenciamento de curso

gestão estudantil

entrada de nota

Estatísticas de desempenho da classe

Gerenciamento de desempenho do aluno

Em quarto lugar, a exibição do código principal

# encoding:utf-8
import json
from io import BytesIO
from django.contrib.auth import logout
from django.contrib.auth.hashers import check_password, make_password
from django.http import JsonResponse, HttpResponse
from django.shortcuts import render, redirect

# Create your views here.
from common.API import res_josn_data
from common.API.auth import add_auth_session, login_required
from common.API.captcha import make_captcha
from common.API.code import check_code
from common.API.echarts import echarts_pie, json_response
from common.API.log import login_log
from login.models import Logo, Log
from sys_manage.models import User, Role, Power, RolePower
from student_score import models as m_model


def index(request):
    if request.method == 'GET':
        return redirect('/login')


def home(request):
    if request.method == 'GET':
        return render(request, 'login/home.html')


def login(request):
    if request.method == 'GET':
        return render(request, 'login/login.html')
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')
        code = request.POST.get('captcha')

        if not username or not password or not code:
            return res_josn_data.fail_api(msg="用户名或密码没有输入")
        s_code = request.session.get("code", None)
        print('验证码:', code, s_code)
        user_ip = request.META.get('REMOTE_ADDR')
        print(user_ip)

        request.session["code"] = None

        if not all([code, s_code]):
            # login_log(request, uid=username, is_access=False, desc='验证码错误,请刷新验证码')
            return res_josn_data.fail_api(msg="验证码错误,请刷新验证码!")

        if code != s_code:
            login_log(request, uid=username, is_access=False, desc='验证码错误')
            return res_josn_data.fail_api(msg="验证码错误")

        user = User.objects.filter(id_number=username).first()

        if user is None:
            login_log(request, uid=username, is_access=False, desc='用户不存在')
            return res_josn_data.fail_api(msg="用户不存在!")

        if user.user_status == 0:
            login_log(request, uid=user.id_number, is_access=False, desc='用户被禁用')
            return res_josn_data.fail_api(msg="用户被禁用!")

        if username == user.id_number and check_password(password, user.id_password):
            # 设置session过期时间
            request.session.set_expiry(60 * 60 * 2)
            # 登录
            request.session["user_id"] = user.id_number
            request.session["user_name"] = user.user_name
            request.session["role_id"] = user.role_id
            request.session["role_des"] = user.role_des
            request.session["id"] = user.id
            # 学校名称
            request.session["department"] = user.department

            # 年级
            request.session["position"] = user.position
            # 科目
            request.session["email"] = user.email
            # 记录登录日志
            login_log(request, uid=user.id_number, is_access=True, desc='登录成功')
            # 存入权限
            add_auth_session(request)

            return res_josn_data.success_api(msg="登录成功")

        else:
            login_log(request, uid=user.id_number, is_access=False, desc='密码错误')
            return res_josn_data.fail_api(msg="密码错误")
def image_code(request):
    """ 生成图片验证码 """

    # 调用pillow函数，生成图片
    img, code_string = check_code()

    # 写入到自己的session中（以便于后续获取验证码再进行校验）
    request.session['image_code'] = code_string
    # 给Session设置60s超时
    request.session.set_expiry(60)

    stream = BytesIO()
    img.save(stream, 'png')
    return HttpResponse(stream.getvalue())


def get_captcha(request):
    return make_captcha(request)


def login_in(request):
    user_id = request.session.get('user_id')
    if user_id:
        return render(request, "login/index.html", {'user_id': user_id})


def login_out(request):
    user_id = request.session.get('user_id')
    login_log(request, uid=user_id, is_access=True, desc='退出登录')
    logout(request)
    return redirect('/login')


@login_required
def web_menu(request):
    home_info = Logo.objects.filter(type='0').first()
    logo_info = Logo.objects.filter(type='1').first()
    title_info = Logo.objects.filter(type='2').first()
    menu_info = Power.objects.filter(type=0).order_by('sort')  # 目录
    # 查询权限ID
    menu_id = RolePower.objects.values_list('power_id').filter(role_id=request.session.get('role_id'))
    permission_id = [i[0] for i in menu_id]
    print(f'当前用户权限ID:{permission_id}')

    menu_data = {
        "homeInfo": {
            "title": f"{home_info.name}",
            "href": f"{home_info.url}"
        },
        "logoInfo": {
            "title": f"{logo_info.name}",
            "image": f"{logo_info.icon}",
            "href": f"{logo_info.url}"
        },
        "menuInfo": [
            {
                "title": f"{title_info.name}",
                "icon": f"{title_info.icon}",
                "href": f"{title_info.url}",
                "target": "_self",
                "child": []
            }
        ]
    }
    for item in menu_info:
        if item.id in permission_id:
            menu_data["menuInfo"][0]["child"].append({
                "title": f"{item.name}",
                "icon": f"{item.icon}",
                "href": f"{item.code}",
                "target": "_self",
                "child": []
            })
            # 查询子菜单
            sub_menu_info = Power.objects.filter(parent_id=item.id).order_by('sort')
            for sub_item in sub_menu_info:
                if sub_item.id in permission_id:
                    menu_data["menuInfo"][0]["child"][-1]["child"].append({
                        "title": f"{sub_item.name}",
                        "icon": f"{sub_item.icon}",
                        "href": f"{sub_item.code}",
                        "target": "_self"
                    })

    return JsonResponse(menu_data, safe=False)


@login_required
def echarts(request):
    if request.method == 'POST':
        n_type = ['用户', '角色', '权限', '日志']
        user_count = User.objects.count()
        role_count = Role.objects.count()
        role_power_count = RolePower.objects.count()
        log_count = Log.objects.count()
        data_list = [user_count, role_count, role_power_count, log_count]
        title = '1.数量统计'
        c = echarts_pie(n_type, data_list, title)
        return json_response(json.loads(c))


@login_required
def user_setting(request):
    if request.method == 'GET':
        return render(request, "login/user_setting.html")
    if request.method == "POST":
        post_data = request.POST
        print(post_data)
        field_user_id = post_data['userID']
        field_name = post_data['userName']
        field_dep = post_data['department']
        field_pos = post_data['position']
        field_email = post_data['email']
        update_dict = {
            'user_name': field_name,
            'department': field_dep,
            'position': field_pos,
            'email': field_email
        }
        User.objects.filter(id_number=field_user_id).update(**update_dict)
        return res_josn_data.success_api(msg=f'用户:{field_user_id} 更新成功')


@login_required
def user_info_query(request):
    data_list = []
    post_data = request.POST
    print('AJAX数据:', post_data)
    login_id = post_data['login_id'].strip()
    user_info = User.objects.filter(id_number=login_id).first()
    role_info = Role.objects.filter(role_value=user_info.role_id).first()

    return res_josn_data.user_setting_api(login_id, user_info.user_name, user_info.department, user_info.position,
                                          role_info.name, user_info.email, data_list)


@login_required
def user_password(request):
    if request.method == 'GET':
        return render(request, "login/user_password.html")
    if request.method == "POST":
        post_data = request.POST
        print(post_data)
        login_id = post_data['login_id'].strip()
        old_password = post_data['Param[old_password]']
        new_password = post_data['Param[new_password]']
        again_password = post_data['Param[again_password]']
        user_obj = User.objects.filter(id_number=login_id).first()
        if not user_obj:
            return res_josn_data.fail_api(msg="用户不存在!")
        if not check_password(old_password, user_obj.id_password):
            return res_josn_data.fail_api(msg="旧密码错误!")
        if new_password != again_password:
            return res_josn_data.fail_api(msg="两次密码不一致!")
        User.objects.filter(id_number=login_id).update(**{'id_password': make_password(new_password)})
        return res_josn_data.success_api(msg="修改成功!")


# def page_not_found(request, exception):
#     return render(request, "errors/404.html", exception)
#
#
# def page_error(request):
#     return render(request, "errors/500.html")

# encoding:utf-8
import json

from django.contrib.auth.hashers import make_password
from django.core.paginator import Paginator
from django.shortcuts import render
from student_score import models as m_model
# Create your views here.

from common.API import res_josn_data
from common.API.auth import login_required, authorize
from sys_manage.models import User, Role


@login_required
def user_manage(request):
    return render(request, 'sys_manage/user_manage/user_main.html')


@login_required
def user_query(request):
    data_list = []
    page = request.POST.get('page', 1)
    limit = request.POST.get('limit', 10)
    post_data_str = request.POST.get('Params', None)

    if post_data_str is None:
        user_obj = User.objects.all().order_by('id')
        # return res_josn_data.table_api(data=data_list, count=0)
    else:
        post_data = json.loads(post_data_str)
        id_number = post_data['idNumber']
        user_name = post_data['userName']
        user_dep = post_data['dep']
        user_pos = post_data['position']
        user_status = post_data['status']
        user_role = post_data['role']

        filters = {}  # 查询参数构造
        # model或数据库对应字段
        orm_field = ['__gt', '__gte', '__lt', '__lte', '__exact', '__iexact', '__contains', '__icontains',
                     '__startswith', '__istartswith', '__endswith', '__iendswith', '__range', '__isnull', '__in']
        filed_dict = {0: 'id_number', 1: 'user_name', 2: 'department', 3: 'position', 4: 'user_status', 5: 'role_id'}
        param_list = [id_number, user_name, user_dep, user_pos, user_status, user_role]

        for i in range(len(param_list)):
            if param_list[i] not in (None, ''):
                db_field = filed_dict[i] + orm_field[7]
                filters[db_field] = param_list[i]

        print('filters:', filters)

        user_obj = User.objects.filter(**filters).order_by('id')
    page_data = Paginator(user_obj, limit).page(page)

    # 序号
    count = (int(page) - 1) * int(limit)

    for item in page_data:
        count += 1
        item_data = {
            "id": count,
            "fieldID": item.id,
            "userID": item.id_number,
            "name": item.user_name,
            "department": item.department,
            "position": item.position,
            "email": item.email,
            "status": item.user_status,
            "role": item.role_des,
        }
        data_list.append(item_data)

    return res_josn_data.table_api(count=len(user_obj), data=data_list)


@authorize(power='user:add', log=True)
def user_add(request):
    if request.method == 'GET':
        return render(request, 'sys_manage/user_manage/user_add.html')
    if request.method == 'POST':
        post_data = request.POST
        print(request.POST)
        user_id = post_data['userID']
        user_password = post_data['password']
        user_name = post_data['userName']
        user_dep = post_data['department']
        user_position = post_data['position']
        user_email = post_data['email']
        user_enable = post_data['enable']
        role_value = post_data['role']

        user_password_sha256 = make_password(user_password, salt=None, hasher='default')
        role_obj = Role.objects.filter(role_value=role_value).first()

        new_obj = User(
            id_number=user_id,
            id_password=user_password_sha256,
            user_name=user_name,
            department=user_dep,
            position=user_position,
            role_id=role_value,
            role_des=role_obj.name,
            user_status=user_enable,
            email=user_email,
        )
        new_obj.save()
        return res_josn_data.success_api(msg=f'用户:{user_name} 添加成功')


@login_required
def user_role_query(request):
    if request.method == 'POST':
        data_list = []
        role_data = Role.objects.all()
        for item in role_data:
            item_data = {
                "roleID": item.role_value,
                "roleName": item.name
            }
            data_list.append(item_data)
        print(data_list)
        return res_josn_data.table_api(data=data_list, count=len(role_data))
def school_query(request):
    if request.method == 'POST':
        data_list = []

        school_data = m_model.College.objects.all()
        for item in school_data:
            item_data = {
                "schoolID": item.id,
                "schoolName": item.name
            }
            data_list.append(item_data)
        return res_josn_data.table_api(data=data_list, count=len(school_data))

@authorize(power='user:delete', log=True)
def user_delete(request):
    if request.method == 'POST':
        post_data = request.POST
        print('AJAX数据:', post_data)
        db_id = post_data['fieldID']
        user_name = post_data['name']
        User.objects.filter(id=db_id).delete()
        return res_josn_data.success_api(f'用户:{user_name} 删除成功')
    else:
        return res_josn_data.fail_api(msg='请求权限不够!')


@authorize(power='user:delete', log=True)
def user_multi_delete(request):
    if request.method == 'POST':
        user_list = []
        post_data_str = request.POST.get('Params', None)
        post_data = json.loads(post_data_str)
        for item in post_data:
            db_id = item['fieldID']
            user_name = item['name']
            User.objects.filter(id=db_id).delete()
            user_list.append(user_name)
        return res_josn_data.success_api(f'用户:{user_list} 删除成功')


@login_required
def user_cell_edit(request):
    # 前端字段和数据库字段对应dict
    filed_dict = {
        'userID': 'id_number',
        'name': 'user_name',
        'department': 'department',
        'position': 'position',
        'email': 'email',
    }
    if request.method == 'POST':
        post_data = request.POST
        print('AJAX数据:', post_data)
        field_name = post_data['field']
        field_value = post_data['value']
        field_id = post_data['dbID']
        User.objects.filter(id=field_id).update(**{filed_dict[field_name]: field_value})
        return res_josn_data.success_api(f'更新成功')


@login_required
def user_role_edit(request):
    if request.method == 'GET':
        return render(request, 'sys_manage/user_manage/user_role_edit.html')
    if request.method == 'POST':
        post_data = request.POST
        print(post_data)
        user_id = post_data['userID']
        role_id = post_data['role']
        role_obj = Role.objects.filter(role_value=role_id).first()
        update_dict = {
            'role_id': role_id,
            'role_des': role_obj.name
        }
        User.objects.filter(id_number=user_id).update(**update_dict)
        return res_josn_data.success_api(msg=f'{user_id} 角色更新成功')


@authorize(power='user:enable', log=True)
def user_enable(request):
    if request.method == 'POST':
        post_data = request.POST
        print('AJAX数据:', post_data)
        field_id = post_data['userID']
        enable_value = post_data['enableValue']  # 0禁用 1启用
        enable_dict = {'enable': 1, 'disable': 0}
        enable_dict_cn = {'enable': '启用', 'disable': '禁用'}
        role_obj = User.objects.filter(id=field_id)
        role_obj.update(**{'user_status': enable_dict[enable_value]})
        return res_josn_data.success_api(msg=f'{role_obj[0].user_name} {enable_dict_cn[enable_value]}成功')

V. Resumo do Projeto

O sistema de gerenciamento de desempenho do aluno desenvolvido e implementado com base em Python também pode ser usado como um sistema de gerenciamento de alunos. O tópico pode ser alterado de acordo com as necessidades, a realização da função é relativamente completa e o design da interface é bonito e generoso. É adequado para projeto de graduação e projeto de curso.