current position:Home>Ape Creation Essay|〖Python Database Development Practice - Python and MySQL Interaction⑰〗 - Project Practice - Implementing User Management - Modifying Users

Ape Creation Essay|〖Python Database Development Practice - Python and MySQL Interaction⑰〗 - Project Practice - Implementing User Management - Modifying Users

2022-09-09 06:49:19Husky not hungry for power


前言
作者简介:渴望力量的哈士奇 ,大家可以叫我 哈士奇 ,一位致力于 TFS - 全栈 赋能的博主
CSDN博客专家认证、新星计划第三季全栈赛道 MVP 、华为云享专家、阿里云专家博主
如果文章知识点有错误的地方,请指正!和大家一起学习,一起进步
人生格言:优于别人,并不高贵,真正的高贵应该是优于过去的自己.
如果感觉博主的文章还不错的话,还请关注、点赞、收藏三连支持一下博主哦


专栏系列(点击解锁)学习路线(点击解锁)知识定位
Python全栈白皮书 零基础入门篇 以浅显易懂的方式轻松入门,让你彻底爱上Python的魅力.
语法进阶篇 主要围绕多线程编程、正则表达式学习、含贴近实战的项目练习 .
自动化办公篇 实现日常办公软件的自动化操作,节省时间、提高办公效率.
自动化测试实战篇 从实战的角度出发,先人一步,快速转型测试开发工程师.
数据库开发实战篇掌握关系型与非关系数据库知识,提升数据库实战开发能力.
爬虫入门与实战更新中
数据分析篇更新中
前端入门+flask 全栈篇更新中
django+vue全栈篇更新中
拓展-人工智能入门更新中
网络安全之路 踩坑篇 记录学习及演练过程中遇到的坑,便于后来居上者
网安知识扫盲篇 三天打鱼,不深入了解原理,只会让你成为脚本小子.
vulhub靶场漏洞复现 让漏洞复现变得简单,让安全研究者更加专注于漏洞原理本身.
shell编程篇 不涉及linux基础,最终案例会偏向于安全加固方向. [待完结]
WEB漏洞攻防篇2021年9月3日停止更新,转战先知社区等安全社区及小密圈
渗透工具使用集锦2021年9月3日停止更新,转战先知社区等安全社区及小密圈
点点点工程师 测试神器 - Charles 软件测试数据包抓包分析神器
测试神器 - Fiddler 一文学会 fiddle ,学不会倒立吃翔,稀得!
测试神器 - Jmeter 不仅是性能测试神器,更可用于搭建轻量级接口自动化测试框架.
RobotFrameWorkPython实现的自动化测试利器,该篇章仅介绍UI自动化部分.
Java实现UI自动化文档写于2016年,Java实现的UI自动化,仍有借鉴意义.
MonkeyRunner该工具目前的应用场景已不多,文档已删,为了排版好看才留着.

在这里插入图片描述


Then continue to finish “新闻管理系统” 的内容,上一章节我们完成了 “用户管理” - “新增用户” 的功能,Then complete the “用户管理” - “修改用户” 的功能吧.



Modify the user functions - “user_dao.py” - 编写 “修改用户” 功能 - search_count_page() 方法


  • 在实现 “修改用户” This function menu,我们需要先实现 Output the list of users ,And then to enter serial number,选择要修改的用户.
  • 既然在 “修改用户” The function of the menu printing "用户列表",Then it must be first "用户列表" 查出来.
  • 除此之外,还需要针对 "Find out the user" 进行分页,所以在 "user_dao.py" Program to implement two methods:"查询用户列表 - search_list" 与 "查询用户记录总数 - search_count_page".

  • 重点新增了 “查询用户总页数” - 第 81 行 - 第 98 行

# coding:utf-8


from db.mysql_db import pool


class UserDao:
    """ 验证用户登录 1、定义 login 方法,传入 username, password 2、针对 login 方法,进行异常捕获 """
    def login(self, username, password):       # 定义 login
        try:                                   # try 语句捕获异常
            con=pool.get_connection()          # 定义一个连接(从连接池取出一个连接)
            cursor=con.cursor()                # 创建游标
            """ 1、将查询用户的预编译 SQL语句 赋值给 sql 2、根据输入的账号、密码查找对应的记录 """
            sql="SELECT COUNT(*) FROM t_user WHERE username=%s AND " \
                "AES_DECRYPT(UNHEX(password),'HelloWorld')=%s"
            cursor.execute(sql, (username, password))       # 利用 游标 执行 SLQ语句
            count=cursor.fetchone()[0]                      # 获取 游标 结果集的第一个结果,并赋值给 count
            return True if count==1 else False              # 如果 count 为1,返回 True(登录成功) ,否则返回 False(登录失败)
        except Exception as e:      # 打印输出异常
            print(e)
        finally:                    # 这里不是 关闭连接 的意思,而是将 连接 归还给 连接池.
            if "con" in dir():
                con.close()
    """ 查询用户角色 1、定义 search_user_role 方法,传入 username 2、将 user表 与 role表做表连接,根据传入的 username 查询用户的身份角色 """
    def search_user_role(self, username):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            """ 1、将查询用户角色的的预编译 SQL语句 赋值给 sql 2、根据传入的用户名查找对应的角色记录 """
            sql="SELECT r.role FROM t_user u JOIN t_role r ON u.role_id=r.id " \
                "WHERE u.username=%s"
            cursor.execute(sql, [username])
            role=cursor.fetchone()[0]           # 获取 游标 结果集的第一个结果,并赋值给 role
            return role                         # 直接返回获取的结果
        except Exception as e:      # 打印输出异常
            print(e)
        finally:                    # 这里不是 关闭连接 的意思,而是将 连接 归还给 连接池.
            if "con" in dir():
                con.close()

    """ 添加用户记录 1、定义 insert() 方法,传入参数 "username"、 "password"、 "email"、 "role_id" 2、针对 insert() 方法 进行异常捕获 """
    def insert(self, username, password, email, role_id):
        try:
            con = pool.get_connection()
            con.start_transaction()
            cursor=con.cursor()
            """ 1、将 添加用户 的的预编译 SQL语句 赋值给 sql 2、需要针对插入的用户的 password 字段进行加密,秘钥 "HelloWorld" """
            sql="INSERT INTO t_user(username,password,email,role_id) " \
                "VALUES(%s,HEX(AES_ENCRYPT(%s,'HelloWorld')),%s,%s)"
            cursor.execute(sql, (username, password, email, role_id))
            con.commit()
        except Exception as e:
            if "con" in dir():
                con.rollback()
            print(e)
        finally:
            if "con" in dir():
                con.close()
                
    """ 查询用户总页数 1、定义 search_count_page() 方法 2、针对 search_count_page() 方法 进行异常捕获 """
    def search_count_page(self):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            sql="SELECT CEIL(COUNT(*)/10) FROM t_user"      # 单表查询;CEIL() 函数是结果有小数位,强制进一位.
            cursor.execute(sql)
            count_page=cursor.fetchone()[0]					# 将 结果集 赋值 给 count_page
            return count_page
        except Exception as e:
            print(e)
        finally:
            if "con" in dir():
                con.close()


Modify the user functions - “user_dao.py” - 编写 “修改用户” 功能 - search_list() 方法


  • 编写 "查询用户列表 - search_list" 方法
  • 重点新增了 “查询用户列表” - 第 100 行 - 第 126 行

# coding:utf-8


from db.mysql_db import pool


class UserDao:
    """ 验证用户登录 1、定义 login 方法,传入 username, password 2、针对 login 方法,进行异常捕获 """
    def login(self, username, password):       # 定义 login
        try:                                   # try 语句捕获异常
            con=pool.get_connection()          # 定义一个连接(从连接池取出一个连接)
            cursor=con.cursor()                # 创建游标
            """ 1、将查询用户的预编译 SQL语句 赋值给 sql 2、根据输入的账号、密码查找对应的记录 """
            sql="SELECT COUNT(*) FROM t_user WHERE username=%s AND " \
                "AES_DECRYPT(UNHEX(password),'HelloWorld')=%s"
            cursor.execute(sql, (username, password))       # 利用 游标 执行 SLQ语句
            count=cursor.fetchone()[0]                      # 获取 游标 结果集的第一个结果,并赋值给 count
            return True if count==1 else False              # 如果 count 为1,返回 True(登录成功) ,否则返回 False(登录失败)
        except Exception as e:      # 打印输出异常
            print(e)
        finally:                    # 这里不是 关闭连接 的意思,而是将 连接 归还给 连接池.
            if "con" in dir():
                con.close()
    """ 查询用户角色 1、定义 search_user_role 方法,传入 username 2、将 user表 与 role表做表连接,根据传入的 username 查询用户的身份角色 """
    def search_user_role(self, username):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            """ 1、将查询用户角色的的预编译 SQL语句 赋值给 sql 2、根据传入的用户名查找对应的角色记录 """
            sql="SELECT r.role FROM t_user u JOIN t_role r ON u.role_id=r.id " \
                "WHERE u.username=%s"
            cursor.execute(sql, [username])
            role=cursor.fetchone()[0]           # 获取 游标 结果集的第一个结果,并赋值给 role
            return role                         # 直接返回获取的结果
        except Exception as e:      # 打印输出异常
            print(e)
        finally:                    # 这里不是 关闭连接 的意思,而是将 连接 归还给 连接池.
            if "con" in dir():
                con.close()

    """ 添加用户记录 1、定义 insert() 方法,传入参数 "username"、 "password"、 "email"、 "role_id" 2、针对 insert() 方法 进行异常捕获 """
    def insert(self, username, password, email, role_id):
        try:
            con = pool.get_connection()
            con.start_transaction()
            cursor=con.cursor()
            """ 1、将 添加用户 的的预编译 SQL语句 赋值给 sql 2、需要针对插入的用户的 password 字段进行加密,秘钥 "HelloWorld" """
            sql="INSERT INTO t_user(username,password,email,role_id) " \
                "VALUES(%s,HEX(AES_ENCRYPT(%s,'HelloWorld')),%s,%s)"
            cursor.execute(sql, (username, password, email, role_id))
            con.commit()
        except Exception as e:
            if "con" in dir():
                con.rollback()
            print(e)
        finally:
            if "con" in dir():
                con.close()

    """ 查询用户总页数 1、定义 search_count_page() 方法 2、针对 search_count_page() 方法 进行异常捕获 """
    def search_count_page(self):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            sql="SELECT CEIL(COUNT(*)/10) FROM t_user"      # 单表查询;CEIL() 函数是结果有小数位,强制进一位.
            cursor.execute(sql)
            count_page=cursor.fetchone()[0]                 # 将 结果集 赋值 给 count_page
            return count_page
        except Exception as e:
            print(e)
        finally:
            if "con" in dir():
                con.close()

    """ Paging query user record 1、定义 search_list() 方法,传入参数 page 2、针对 search_list() 方法,进行异常捕获 """
    def search_list(self, page):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            """ 1、Use a table join queries,Get the user table id、username 及 Of the role of the table role 2、Will be pre-compiled query assigned to sql 3、 """
            sql="SELECT u.id,u.username,r.role " \
                "FROM t_user u JOIN t_role r " \
                "ON u.role_id=r.id " \
                "ORDER BY u.id " \
                "LIMIT %s,%s"
            cursor.execute(sql, ((page-1)*10, 10))
            result=cursor.fetchall()
            return result
        except Exception as e:
            print(e)
        finally:
            if "con" in dir():
                con.close()


Modify the user functions - “user_service.py” - 编写 “修改用户” 功能 - search_count_page() 与 search_list() 方法


  • 重点新增了 “查询用户总页数” 与 “查询用户分页记录” - 第 36 行 - 第 52 行

# coding:utf-8


from db.user_dao import UserDao


class UserService:
    __user_dao=UserDao()    # 实例化 UserDao() 对象 ---> __user_dao "私有变量"

    """ 定义登录方法 1、login方法,传参 "username" 与 "password" 2、调用 __user_dao 实例的 login 方法赋值给 "result",并返回结果 """
    def login(self, username, password):
        result = self.__user_dao.login(username, password)
        return result

    """ 定义查询用户身份方法 1、search_user_role,传参 "username" 2、调用 __user_dao 实例的 search_user_role 方法赋值给 "role",并返回结果 """
    def search_user_role(self, username):
        role = self.__user_dao.search_user_role(username)
        return role

    """ 添加用户记录 1、定义 insert() 方法,传入参数 "username"、 "password"、 "email"、 "role_id" 2、调用 __user_dao 实例的 insert() 方法 """
    def insert(self, username, password, email, role_id):
        self.__user_dao.insert(username, password, email, role_id)

    """ 查询用户总页数 1、定义 search_count_page() 方法 2、调用 __user_dao 实例的 search_count_page() 方法 """
    def search_count_page(self):
        count_page = self.__user_dao.search_count_page()
        return count_page

    """ 查询用户分页记录 1、定义 search_list() 方法,传入参数 page 2、调用 __user_dao 实例的 search_list 方法 """
    def search_list(self, page):
        result = self.__user_dao.search_list(page)
        return result


Modify the user functions - “user_dao.py” - 编写 “修改用户” 功能 - update() 方法


  • 重点新增了 “修改用户记录” - 第 127 行 - 第 153 行

# coding:utf-8


from db.mysql_db import pool


class UserDao:
    """ 验证用户登录 1、定义 login 方法,传入 username, password 2、针对 login 方法,进行异常捕获 """
    def login(self, username, password):       # 定义 login
        try:                                   # try 语句捕获异常
            con=pool.get_connection()          # 定义一个连接(从连接池取出一个连接)
            cursor=con.cursor()                # 创建游标
            """ 1、将查询用户的预编译 SQL语句 赋值给 sql 2、根据输入的账号、密码查找对应的记录 """
            sql="SELECT COUNT(*) FROM t_user WHERE username=%s AND " \
                "AES_DECRYPT(UNHEX(password),'HelloWorld')=%s"
            cursor.execute(sql, (username, password))       # 利用 游标 执行 SLQ语句
            count=cursor.fetchone()[0]                      # 获取 游标 结果集的第一个结果,并赋值给 count
            return True if count==1 else False              # 如果 count 为1,返回 True(登录成功) ,否则返回 False(登录失败)
        except Exception as e:      # 打印输出异常
            print(e)
        finally:                    # 这里不是 关闭连接 的意思,而是将 连接 归还给 连接池.
            if "con" in dir():
                con.close()
    """ 查询用户角色 1、定义 search_user_role 方法,传入 username 2、将 user表 与 role表做表连接,根据传入的 username 查询用户的身份角色 """
    def search_user_role(self, username):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            """ 1、将查询用户角色的的预编译 SQL语句 赋值给 sql 2、根据传入的用户名查找对应的角色记录 """
            sql="SELECT r.role FROM t_user u JOIN t_role r ON u.role_id=r.id " \
                "WHERE u.username=%s"
            cursor.execute(sql, [username])
            role=cursor.fetchone()[0]           # 获取 游标 结果集的第一个结果,并赋值给 role
            return role                         # 直接返回获取的结果
        except Exception as e:      # 打印输出异常
            print(e)
        finally:                    # 这里不是 关闭连接 的意思,而是将 连接 归还给 连接池.
            if "con" in dir():
                con.close()

    """ 添加用户记录 1、定义 insert() 方法,传入参数 "username"、 "password"、 "email"、 "role_id" 2、针对 insert() 方法 进行异常捕获 """
    def insert(self, username, password, email, role_id):
        try:
            con = pool.get_connection()
            con.start_transaction()
            cursor=con.cursor()
            """ 1、将 添加用户 的的预编译 SQL语句 赋值给 sql 2、需要针对插入的用户的 password 字段进行加密,秘钥 "HelloWorld" """
            sql="INSERT INTO t_user(username,password,email,role_id) " \
                "VALUES(%s,HEX(AES_ENCRYPT(%s,'HelloWorld')),%s,%s)"
            cursor.execute(sql, (username, password, email, role_id))
            con.commit()
        except Exception as e:
            if "con" in dir():
                con.rollback()
            print(e)
        finally:
            if "con" in dir():
                con.close()

    """ 查询用户总页数 1、定义 search_count_page() 方法 2、针对 search_count_page() 方法 进行异常捕获 """
    def search_count_page(self):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            sql="SELECT CEIL(COUNT(*)/10) FROM t_user"      # 单表查询;CEIL() 函数是结果有小数位,强制进一位.
            cursor.execute(sql)
            count_page=cursor.fetchone()[0]                 # 将 结果集 赋值 给 count_page
            return count_page
        except Exception as e:
            print(e)
        finally:
            if "con" in dir():
                con.close()

    """ Paging query user record 1、定义 search_list() 方法,传入参数 page 2、针对 search_list() 方法,进行异常捕获 """
    def search_list(self, page):
        try:
            con=pool.get_connection()
            cursor=con.cursor()
            """ 1、Use a table join queries,Get the user table id、username 及 Of the role of the table role 2、Will be pre-compiled query assigned to sql """
            sql="SELECT u.id,u.username,r.role " \
                "FROM t_user u JOIN t_role r " \
                "ON u.role_id=r.id " \
                "ORDER BY u.id " \
                "LIMIT %s,%s"
            cursor.execute(sql, ((page-1)*10, 10))
            result=cursor.fetchall()
            return result
        except Exception as e:
            print(e)
        finally:
            if "con" in dir():
                con.close()

    """ 修改用户信息 1、定义 update() 方法,传入参数 id、 username、 password、 email、 role_id 2、针对 update() 方法,进行异常捕获 """
    def update(self, id, username, password, email, role_id):
        try:
            con = pool.get_connection()
            con.start_transaction()
            cursor=con.cursor()
            """ 1、将 修改用户 的的预编译 SQL语句 赋值给 sql 2、需要针对插入的用户的 password 字段进行加密,秘钥 "HelloWorld" """
            sql="UPDATE t_user SET username=%s," \
                "password=HEX(AES_ENCRYPT(%s,'HelloWorld'))," \
                "email=%s,role_id=%s " \
                "WHERE id=%s"
            cursor.execute(sql, (username, password, email, role_id, id))
            con.commit()
        except Exception as e:
            if "con" in dir():
                con.rollback()
            print(e)
        finally:
            if "con" in dir():
                con.close()


Modify the user functions - “user_service.py” - 编写 “修改用户” 功能 - update() 方法


  • 重点新增了 “修改用户记录” - 第 54 行 - 第 60 行

# coding:utf-8


from db.user_dao import UserDao


class UserService:
    __user_dao=UserDao()    # 实例化 UserDao() 对象 ---> __user_dao "私有变量"

    """ 定义登录方法 1、login方法,传参 "username" 与 "password" 2、调用 __user_dao 实例的 login 方法赋值给 "result",并返回结果 """
    def login(self, username, password):
        result = self.__user_dao.login(username, password)
        return result

    """ 定义查询用户身份方法 1、search_user_role,传参 "username" 2、调用 __user_dao 实例的 search_user_role 方法赋值给 "role",并返回结果 """
    def search_user_role(self, username):
        role = self.__user_dao.search_user_role(username)
        return role

    """ 添加用户记录 1、定义 insert() 方法,传入参数 "username"、 "password"、 "email"、 "role_id" 2、调用 __user_dao 实例的 insert() 方法 """
    def insert(self, username, password, email, role_id):
        self.__user_dao.insert(username, password, email, role_id)

    """ 查询用户总页数 1、定义 search_count_page() 方法 2、调用 __user_dao 实例的 search_count_page() 方法 """
    def search_count_page(self):
        count_page = self.__user_dao.search_count_page()
        return count_page

    """ 查询用户分页记录 1、定义 search_list() 方法,传入参数 page 2、调用 __user_dao 实例的 search_list 方法 """
    def search_list(self, page):
        result = self.__user_dao.search_list(page)
        return result

    """ 修改用户信息 1、定义 update() 方法,传入参数 id、 username、 password、 email、 role_id 2、调用 __user_dao 实例的 update 方法 """
    def update(self, id, username, password, email, role_id):
        self.__user_dao.update(id, username, password, email, role_id)


Modify the user functions - “app.py” - 编写 “修改用户” 功能


  • 重点新增了 “修改用户记录” - 第 212 行 - 第 265 行

# coding:utf-8


from colorama import Fore, Style
from getpass import getpass     # 该模块的作用是遮挡输入的密码
from service.user_service import UserService
from service.news_service import NewsService
from service.role_service import RoleService
import os                       # os 模块的作用是利用 "clear" 系统命令(win电脑 - "cls"),清空控制台的内容
import sys                      # sys 模块的作用主要是利用 "exit()" 方法进行安全退出;(释放数据库连接、文件连接...之后退出)
import time


__user_service = UserService()      # 实例化 UserService() 对象,赋值给私有变量 "__user_service"
__news_service = NewsService()
__role_service = RoleService()

while 1:
    os.system("clear")      # 清空控制台
    print(Fore.LIGHTBLUE_EX, "\n\t=========================")       # "\n":换行 ;"\t":table,四个空格.
    print(Fore.LIGHTBLUE_EX, "\n\t欢迎使用新闻管理系统")
    print(Fore.LIGHTBLUE_EX, "\n\t=========================")
    print(Fore.LIGHTGREEN_EX, "\n\t1.登录系统")
    print(Fore.LIGHTGREEN_EX, "\n\t2.退出系统")
    print(Style.RESET_ALL)                     # 重置字体的颜色
    # opt = input("\n\t请输入操作编号:") # 将用户输入的内容 赋值给变量 opt
    opt=input("\n\t输入操作编号:")
    """ 对用户输入的交互内容进行校验 1、输入 "1" ,进入 "登录系统" 2、输入 "2" ,则退出系统 """
    if opt=="1":                               # 当用户输入 1,进行 登录系统
        username = input("\n\t用户名:")
        password = getpass("\n\t密码:")        # 使用 getpass() 可以将输入的密码 隐去
        result = __user_service.login(username, password)       # 调用 __user_service 的 login 方法,实现登录;赋值给 result

        """ 针对登录成功用户进行身份校验 1、为 True ,判断 登录用户 的身份,根据对应的身份,进入对应的身份层级的轮询 2、为 False ,则 登录失败,返回 登录 层级的轮询 """
        if result == True:
            role = __user_service.search_user_role(username)    # 调用 __user_service 的 search_user_role 方法,校验用户身份
            os.system("clear")

            """ 判断登陆成功后的身份;"新闻编辑" 与 "管理员" 分别跳转各自对应的菜单层级 """
            while 1:
                os.system("clear")  # 清空终端信息
                if role == "新闻编辑":
                    print("*****临时占位符*****")
                elif role == "管理员":
                    print(Fore.LIGHTGREEN_EX, "\n\t1.新闻管理")
                    print(Fore.LIGHTGREEN_EX, "\n\t2.用户管理")
                    print(Fore.LIGHTRED_EX, "\n\tback.退出登录")
                    print(Fore.LIGHTRED_EX, "\n\texit.退出系统 ")
                    print(Style.RESET_ALL)
                    opt = input("\n\t请输入操作编号:")

                    """ 根据登录用户键入的选项,执行对应的操作 """
                    if opt == "1":
                        """ 选项 1 :进入 "新闻管理" 三级菜单(轮询) """
                        while 1:
                            os.system("clear")        # 清空终端信息
                            print(Fore.LIGHTGREEN_EX, "\n\t1.审批新闻")         #
                            print(Fore.LIGHTGREEN_EX, "\n\t2.删除新闻")
                            print(Fore.LIGHTRED_EX, "\n\tback.返回上一层")
                            print(Style.RESET_ALL)
                            opt = input("\n\t输入操作编号:")          # 根据输入的选项,执行对应的操作
                            if opt=="1":
                                """ 选项 1 :进入 "审批新闻" 四级菜单(轮询) """
                                page=1      # 定义 page 变量,保存当前是 "第1页"
                                            # page 这个变量不能定义在 while 循环内,定义在 while 内,每一次轮询都会重置 page
                                while 1:
                                    os.system("clear")    # 清空终端
                                    """ 1、需要导入 service包 news_service模块 NewsService类,将其赋值给 私有变量 ---> __news_service 2、__news_service 私有变量 参考 第 14 行代码 """
                                    count_page=__news_service.search_unreview_count_page()  # 调用查询"待审批新闻"总页数的方法
                                    result=__news_service.search_unreview_list(page)        # 将第1页的结果集赋值给 result

                                    """ 将结果集通过索引的形式进行一个 for 循环输出 """
                                    for index in range(len(result)):
                                        one=result[index]
                                        print(Fore.LIGHTBLUE_EX, "\n\t%d\t%s\t%s\t%s" %(index+1, one[1], one[2], one[3]))
                                    print(Fore.LIGHTBLUE_EX, "\n\t-------------------")
                                    print(Fore.LIGHTBLUE_EX, "\n\t%d/%d" %(page, count_page))
                                    print(Fore.LIGHTBLUE_EX, "\n\t-------------------")
                                    print(Fore.LIGHTRED_EX, "\n\tback.返回上一层")
                                    print(Fore.LIGHTRED_EX, "\n\tprev.上一页")
                                    print(Fore.LIGHTRED_EX, "\n\tnext.下一页")
                                    print(Style.RESET_ALL)
                                    opt = input("\n\t输入操作编号:")
                                    """ 针对用户的输入进行 判断; """
                                    if opt=="back":     # 返回上一层
                                        break
                                    elif opt=="prev" and page>1:    # 向 "上一页" 翻页,前置条件不能为 "第一页"
                                        page-=1
                                    elif opt=="next" and page<count_page:   # 向 "下一页" 翻页,前置条件不能为 "最后一页"
                                        page+=1
                                    elif int(opt) >= 1 and int(opt) <= 10:
                                        """ 1、这里的 opt 获取到输入的编号是 string 类型,需要先转成 int 类型 2、因为每一页的新闻数量是十条,所以输入的取值范围是 大于等于1、小于等于10 3、在获取输入的记录时,这里获取的新闻的id并不是数据库中新闻记录的主键id 4、传入的记录其实是显示在终端的待审批新闻的索引,所以我们需要将传入的记录换算为 "待审批新闻" 的索引位 """
                                        news_id = result[int(opt) - 1][0]
                                        __news_service.update_unreview_news(news_id)
                            elif opt=="2":
                                """ 选项 2 :进入 "删除新闻" 四级菜单(轮询) """
                                page = 1  # 定义 page 变量,保存当前是 "第1页"
                                # page 这个变量不能定义在 while 循环内,定义在 while 内,每一次轮询都会重置 page
                                while 1:
                                    os.system("clear")  # 清空终端
                                    """ 1、需要导入 service包 news_service模块 NewsService类,将其赋值给 私有变量 ---> __news_service 2、__news_service 私有变量 参考 第 14 行代码 """
                                    count_page = __news_service.search_count_page()  # 调用 "新闻总页数" 的方法
                                    result = __news_service.search_list(page)        # 将查询 "新闻列表" 的结果集赋值给 result

                                    """ 将结果集通过索引的形式进行一个 for 循环输出 """
                                    for index in range(len(result)):
                                        one = result[index]
                                        print(Fore.LIGHTBLUE_EX,
                                              "\n\t%d\t%s\t%s\t%s" % (index + 1, one[1], one[2], one[3]))
                                    print(Fore.LIGHTBLUE_EX, "\n\t-------------------")
                                    print(Fore.LIGHTBLUE_EX, "\n\t%d/%d" % (page, count_page))
                                    print(Fore.LIGHTBLUE_EX, "\n\t-------------------")
                                    print(Fore.LIGHTRED_EX, "\n\tback.返回上一层")
                                    print(Fore.LIGHTRED_EX, "\n\tprev.上一页")
                                    print(Fore.LIGHTRED_EX, "\n\tnext.下一页")
                                    print(Style.RESET_ALL)
                                    opt = input("\n\t输入操作编号:")
                                    """ 针对用户的输入进行 判断; """
                                    if opt == "back":  # 返回上一层
                                        break
                                    elif opt == "prev" and page > 1:  # 向 "上一页" 翻页,前置条件不能为 "第一页"
                                        page -= 1
                                    elif opt == "next" and page < count_page:  # 向 "下一页" 翻页,前置条件不能为 "最后一页"
                                        page += 1
                                    elif int(opt) >= 1 and int(opt) <= 10:
                                        """ 1、这里的 opt 获取到输入的编号是 string 类型,需要先转成 int 类型 2、因为每一页的新闻数量是十条,所以输入的取值范围是 大于等于1、小于等于10 3、在获取输入的记录时,这里获取的新闻的id并不是数据库中新闻记录的主键id 4、传入的记录其实是显示在终端的新闻记录的索引,所以我们需要将传入的记录换算为 "新闻记录" 的索引位 """
                                        news_id = result[int(opt)-1][0]
                                        __news_service.delete_by_id(news_id)
                            elif opt == "back":
                                break
                    elif opt == "2":
                        """ 选项 2 :进入 "用户管理" 三级菜单(轮询) """
                        while True:
                            os.system("clear")
                            print(Fore.LIGHTGREEN_EX, "\n\t1.添加用户")
                            print(Fore.LIGHTGREEN_EX, "\n\t2.修改用户")
                            print(Fore.LIGHTGREEN_EX, "\n\t3.删除用户")
                            print(Fore.LIGHTRED_EX, "\n\tback.返回上一层")
                            print(Style.RESET_ALL)
                            opt = input("\n\t输入操作编号:")
                            if opt=="back":
                                break
                            elif opt=="1":
                                """ 选项 1 :进入 "添加用户" 四级菜单(轮询) """
                                os.system("clear")
                                username=input("\n\t用户名:")
                                password = getpass("\n\t密码:")        # getpass() 遮挡输入的密码
                                repassword=getpass("\n\t重复密码:")     # 密码需要输入两次,且需要针对两次密码进行相等判断
                                if password!=repassword:              # 两次密码不一致,进入下一次的轮询
                                    print("\n\t两次密码不一致(3秒自动返回)")
                                    time.sleep(3)
                                    continue
                                email=input("\n\t邮箱:")
                                result=__role_service.search_list()     # 向控制台输出已有的角色列表
                                                                        # 此处需要导入 service包 role_service模块 的 RoleService类
                                                                        # 参考 第 8 行 与 第 16 行 代码
                                for index in range(len(result)):        # 循环输出 "角色列表" 的结果集
                                    one=result[index]
                                    print(Fore.LIGHTBLUE_EX, "\n\t%d.%s" %(index+1, one[1]))
                                print(Style.RESET_ALL)
                                opt=input("\n\t角色编号:")          # 根据输入的内容,将其换算为 "角色编号"
                                role_id=result[int(opt)-1][0]
                                __user_service.insert(username, password, email, role_id)
                                print("\n\t保存成功(3秒自动返回)")
                                time.sleep(3)
                            elif opt=="2":
                                page = 1
                                while True:
                                    os.system("clear")
                                    count_page = __user_service.search_count_page()
                                    result = __user_service.search_list(page)
                                    for index in range(len(result)):
                                        one = result[index]
                                        print(Fore.LIGHTBLUE_EX,
                                              "\n\t%d\t%s\t%s" % (index + 1, one[1], one[2]))
                                    print(Fore.LIGHTBLUE_EX, "\n\t-------------------")
                                    print(Fore.LIGHTBLUE_EX, "\n\t%d/%d" % (page, count_page))
                                    print(Fore.LIGHTBLUE_EX, "\n\t-------------------")
                                    print(Fore.LIGHTRED_EX, "\n\tback.返回上一层")
                                    print(Fore.LIGHTRED_EX, "\n\tprev.上一页")
                                    print(Fore.LIGHTRED_EX, "\n\tnext.下一页")
                                    print(Style.RESET_ALL)
                                    opt = input("\n\t输入操作编号:")
                                    if opt == "back":
                                        break
                                    elif opt == "prev" and page > 1:
                                        page -= 1
                                    elif opt == "next" and page < count_page:
                                        page += 1
                                    elif int(opt) >= 1 and int(opt) <= 10:
                                        """ 1、这里的 opt 获取到输入的编号是 string 类型,需要先转成 int 类型 2、Every page because the number of users is ten,所以输入的取值范围是 大于等于1、小于等于10 3、在获取输入的记录时,Here for the user'sid并不是数据库中新闻记录的主键id 4、The incoming record is displayed on the terminal user's index,所以我们需要将传入的记录换算为 "用户记录" 的索引位 """
                                        os.system("clear")
                                        user_id=result[int(opt)-1][0]       # Access to the terminal display user record index corresponding userid
                                        username = input("\n\t新用户名:")
                                        password = getpass("\n\t新密码:")
                                        repassword = getpass("\n\t再次输入密码:")
                                        if password!=repassword:
                                            print(Fore.LIGHTRED_EX, "\n\t两次密码不一致(3秒自动返回)")
                                            print(Style.RESET_ALL)
                                            time.sleep(3)
                                            break
                                        email = input("\n\t新邮箱:")
                                        result = __role_service.search_list()
                                        for index in range(len(result)):        # 循环输出 "角色列表" 的结果集
                                            one = result[index]
                                            print(Fore.LIGHTBLUE_EX, "\n\t%d.%s" % (index + 1, one[1]))
                                        print(Style.RESET_ALL)
                                        opt = input("\n\t角色编号:")
                                        role_id = result[int(opt) - 1][0]
                                        opt=input("\n\t是否保存(Y/N)")
                                        if opt=="Y" or opt=="y":
                                            __user_service.update(user_id, username, password, email, role_id)
                                            print("\n\t保存成功(3秒自动返回)")
                                            time.sleep(3)
                    elif opt == "back":         # 返回上一级层级菜单
                        break
                    elif opt == "exit":         # 安全退出
                        sys.exit(0)
        else:
            print("\n\t*****登录失败...3秒后自动返回!*****")
            time.sleep(3)
    elif opt=="2":
        sys.exit(0)     # 安全退出 ---> 利用 "exit()" 方法安全退出;(释放数据库连接、文件连接...之后退出)

copyright notice
author[Husky not hungry for power],Please bring the original link to reprint, thank you.
https://en.pythonmana.com/2022/252/202209090636248249.html

Random recommended