ATM项目

目录

• ATM项目开发流程
  • 1)项目分析
  • 2)项目功能搭建
  • 3)项目架构设计
  • 4)项目目录搭建
• ATM项目代码
  • 1.bin文件夹
    • start.py
  • 2.conf文件夹
    • settings.py
  • 3.core文件夹
    • src.py
  • 4.db文件夹
    • db_handler.py
  • 5.interface文件夹
    • user_interface.py
    • bank_interface.py
    • shop_interface.py
    • admin_interface.py
  • 6.lib文件夹
    • common.py

ATM项目开发流程

1)项目需求分析
所需人员：产品经理、开发经历、架构师

架构师 开发经历提前构思大致安敢
引导客户提出合理要求(避免不合理要求)
记录会议内容

2)项目架构设计
所需人员：架构师

项目编程语言
项目整体框架：框架、数据库服务
项目报价

3)项目分组开发
所需人员：架构师、开发经理、程序员

任务拆分开发

4)项目提交测试
所需人员：自己先测一遍

提交给专门测试的部门

5)项目交付上线
所需人员：运维

1)项目分析

额度15000或自定义
支持多账户登录
可以查看账户余额
可以提现(可自定义手续费比例)
提供充值接口
支持账户间转账
记录每月日常消费流水
实现购物商城，买东西加入购物车，调用信用卡接口结账
提供管理接口，包括添加账户、用户额度，冻结账户等
ATM记录操作日志
用户认证功能

2)项目功能搭建

所有用户功能：
    1.用户注册  【管理员申请码：admin】
    2.用户登录
    3.查看余额
    4.提现金额
    5.充值金额
    6.转账金额
    7.查看流水
    8.添加购物车
    9.查看购物车
   10.结算购物车
   11.管理员后台
管理员功能：
    1.管理员冻结账户
    2.管理员解冻账户
    3.管理员删除账户
    4.查看用户购物车
    5.清空用户购物车
    6.给用户账户充值
    7.查看用户的余额
    8.查看用户的流水
    9.重置用户的密码
   10.退出管理员后台

3)项目架构设计

三层架构
1.功能展示层：数据展示、数据获取
2.核心逻辑层：分成多个py文件,里面是各个功能接口
3.数据处理层：数据的增删改查

4)项目目录搭建

1.bin文件夹         'start.py'
    启动文件#可有可无,启动文件也可放根目录下
2.conf文件夹        'settings.py'
    配置文件#里面都是不常改变的常量:常量名大写
3.core文件夹        'src.py'
    核心逻辑#存放项目核心功能文件
4.interface文件夹   '注册、登录..'
    接口文件#根据具体业务逻辑划分对应文件
5.lib文件夹         'common.py'
    公共功能#很多文件都要使用
6.db文件夹          'userinfo.txt'
    存储用户数据#注册后的用户信息,今后会被数据库代替
7.log文件夹         'log.log'
    日志文件#今后会被日志模块代替
8.readme.txt文件
    使用说明书
9.requirements.txt文件
    第三方模块#存放该程序需要的第三方模块和版本

ATM项目代码

1.bin文件夹

start.py

from conf import settings
import sys

sys.path.append(settings.BASE_DIR)

if __name__ == '__main__':
    from core import src
    src.run()

2.conf文件夹

settings.py

import os

BASE_DIR = os.path.dirname(os.path.dirname(__file__))
DB_DIR = os.path.join(BASE_DIR, 'db')

# 手续费
SXF = 0.01

# 定义日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]'  # 其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
# 自定义文件路径
# logfile_path = 'a3.log'
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
LOG_DIR = os.path.join(BASE_DIR, 'log')
if not os.path.exists(LOG_DIR):
    os.makedirs(LOG_DIR)
logfile_path = os.path.join(LOG_DIR, 'log.log')  # 【可以起一个日志名字.log】
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},  # 过滤日志
    'handlers': {
        # 打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        # 打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
            'backupCount': 5,  # 最多保存5份5M的文件,个数够了就删第一个
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        # logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
    },
}

3.core文件夹

src.py

from interface import user_interface, bank_interface, shop_interface, admin_interfac
from lib import common

is_login = {
    'username': '',
    'is_amin': '',
}


# 注册
def register():
    while True:
        username = input('输入要注册的用户名：').strip()
        password = input('输入要注册的密码：').strip()
        password1 = input('再次确认密码：').strip()
        if not password == password1:
            print('两次密码不一致,请重新输入')
            continue
        admin_num = input('输入管理员申请码(没有则按回车)：').strip()
        # 调用第二层注册接口
        flag, msg = user_interface.register_interface(username, password, admin_num)
        print(msg)
        break


# 登录
def login():
    username = input('输入登录用户名：').strip()
    password = input('输入登录密码：').strip()
    # 调用第二层登录接口
    flag, msg = user_interface.login_interface(username, password)
    if flag:
        is_login['username'] = username
        is_login['is_admin'] = msg[1]
    print(msg[0])


# 查看余额
@common.outer_plus('no')
def check_balance():
    # 调用第二层查看余额接口
    flag, msg = bank_interface.check_balance_interface(is_login.get('username'))
    print(msg)


# 提现
@common.outer_plus('no')
def withdraw():
    target_money = input('输入要提现的金额：').strip()
    # 调用第二层提现金额接口
    flag, msg = bank_interface.withdraw_interface(is_login.get('username'), target_money)
    print(msg)


# 充值
@common.outer_plus('no')
def recharge():
    target_money = input('输入要充值的金额：').strip()
    # 调用第二层充值金额接口
    flag, msg = bank_interface.recharge_interface(is_login.get('username'), target_money)
    print(msg)


# 转账
@common.outer_plus('no')
def transfer():
    target_user = input('输入要转账的用户：').strip()
    target_money = input('输入要转账的金额：').strip()
    # 调用第二层转账金额接口
    flag, msg = bank_interface.transfer_interface(is_login.get('username'), target_user, target_money)
    print(msg)


# 查看流水
@common.outer_plus('no')
def check_bank_flow():
    # 调用第二层查看流水接口
    flag, msg = bank_interface.check_bank_flow_interface(is_login.get('username'))
    if not flag:
        print(msg)
    print(f'用户{is_login.get("username")}流水账单：')
    for i in msg:
        print(i)


# 添加购物车
@common.outer_plus('no')
def add_shop_car():
    # 调用第二层添加购物车接口
    flag, msg = shop_interface.add_shop_car_interface(is_login.get('username'))
    print(msg)


# 查看购物车
@common.outer_plus('no')
def check_shop_car():
    # 调用第二层查看购物车接口
    flag, msg = shop_interface.check_shop_car_interface(is_login.get('username'))
    if flag:
        print(f'用户{is_login.get("username")}购物车清单：')
        for i, j in msg.items():
            print(f'商品名称：{i}  购买数量：{j[0]}  商品单价：{j[1]}')
    else:
        print(msg)


# 结算购物车
@common.outer_plus('no')
def pay_shop_car():
    # 调用第二层结算购物车接口
    flag, msg = shop_interface.pay_shop_car_interface(is_login.get('username'))
    print(msg)


# 冻结账户
def frozen_user():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要冻结的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层冻结账户接口
        flag1, msg1 = admin_interfac.frozen_user_interface(is_login.get('username'), target_user)
        print(msg1)
        break


# 解冻账户
def unfrozen_user():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要解冻的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层解冻账户接口
        flag1, msg1 = admin_interfac.unfrozen_user_interface(is_login.get('username'), target_user)
        print(msg1)
        break


# 删除账户
def del_user():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要删除的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层删除账户接口
        flag1, msg1 = admin_interfac.del_user_interface(is_login.get('username'), target_user)
        print(msg1)
        break


# 查看用户购物车
def admin_check_user_shop_car():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要查看购物车的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层查看用户购物车接口
        flag1, msg1 = admin_interfac.admin_check_user_shop_car_interface(is_login.get('username'), target_user)
        if flag1:
            print(f'用户{target_user}购物车清单：')
            for i, j in msg1.items():
                print(f'商品名称：{i}  购买数量：{j[0]}  商品单价：{j[1]}')
                break
        else:
            print(msg1)
            break


# 清空用户购物车
def clear_user_shop_car():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要清空购物车的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层清空用户购物车接口
        flag1, msg1 = admin_interfac.clear_user_shop_car_interface(is_login.get('username'), target_user)
        print(msg1)
        break


# 给用户加钱
def add_user_balance():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要加钱的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层给用户加钱接口
        target_money = input('输入要加钱的金额：').strip()
        flag1, msg1 = admin_interfac.add_user_balance_interface(is_login.get('username'), target_user, target_money)
        print(msg1)
        break


# 查看用户余额
def admin_check_user_balance():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要查看余额的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层查看用户余额接口
        flag1, msg1 = admin_interfac.admin_check_user_balance_interface(is_login.get('username'), target_user)
        print(msg1)
        break


# 管理员查看用户流水账单
def admin_check_user_bank_flow():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要查看流水账单的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        # 调用第二层查看用户余额接口
        flag1, msg1 = admin_interfac.admin_check_user_bank_flow_interface(is_login.get('username'), target_user)
        if not flag1:
            print(msg1)
            break
        print(f'用户{target_user}流水账单：')
        for i in msg1:
            print(i)
        break


# 重置用户密码
def reset_pwd():
    while True:
        # 调用第二层获取用户文件名接口
        flag, msg = admin_interfac.user_file_interface(is_login.get('username'))
        for i, j in enumerate(msg, start=1):
            print(f'编号：{i}  用户名：{j}')
        choice = input('输入要重置密码的用户编号：').strip()
        if not choice.isdigit():
            print('用户编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(msg) + 1):
            print('用户编号不存在')
            continue
        target_user = msg[choice - 1]
        password = input(f'您要把{target_user}密码改为：').strip()
        # 调用第二层重置用户密码接口
        flag1, msg1 = admin_interfac.reset_pwd_interface(is_login.get('username'), target_user, password)
        print(msg1)
        break


# 退出
def quit_admin():
    print('正在退出管理员后台进入上一层中..')
    run()


admin_dict = {
    '1': frozen_user,
    '2': unfrozen_user,
    '3': del_user,
    '4': admin_check_user_shop_car,
    '5': clear_user_shop_car,
    '6': add_user_balance,
    '7': admin_check_user_balance,
    '8': admin_check_user_bank_flow,
    '9': reset_pwd,
    '10': quit_admin,
}


# 管理员
@common.outer_plus('admin')
def admin():
    while True:
        print(f"""
    欢迎管理员{is_login.get("username")}进入后台：
        1.管理员冻结账户
        2.管理员解冻账户
        3.管理员删除账户
        4.查看用户购物车
        5.清空用户购物车
        6.给用户账户充值
        7.查看用户的余额
        8.查看用户的流水
        9.重置用户的密码
       10.退出管理员后台
        """)
        choice = input('输入您要执行的功能：').strip()
        if choice in admin_dict:
            admin_dict.get(choice)()
        else:
            print('暂无该功能')


func_dict = {
    '1': register,
    '2': login,
    '3': check_balance,
    '4': withdraw,
    '5': recharge,
    '6': transfer,
    '7': check_bank_flow,
    '8': add_shop_car,
    '9': check_shop_car,
    '10': pay_shop_car,
    '11': admin,
}


def run():
    while True:
        print("""
      欢迎进入ATM界面：
        1.用户注册
        2.用户登录
        3.查看余额
        4.提现金额
        5.充值金额
        6.转账金额
        7.查看流水
        8.添加购物车
        9.查看购物车
       10.结算购物车
       11.管理员后台
        """)
        choice = input('输入您要执行的功能：').strip()
        if choice in func_dict:
            func_dict.get(choice)()
        else:
            print('暂无该功能')

4.db文件夹

db_handler.py

from conf import settings
import os
import json


# 查询用户接口
def select(username):
    user_path = os.path.join(settings.DB_DIR, f'{username}.json')
    if os.path.exists(user_path):
        with open(user_path, 'r', encoding='utf8')as f:
            return json.load(f)


# 保存用户接口
def save(user_dict):
    user_path = os.path.join(settings.DB_DIR, f'{user_dict.get("username")}.json')
    with open(user_path, 'w', encoding='utf8')as f:
        json.dump(user_dict, f, ensure_ascii=False)


# 查看所有用户文件接口
def check_user_file(username):
    user_file_list = os.listdir(settings.DB_DIR)
    # 筛选
    user_file_list = [i.split('.')[0] for i in user_file_list if i.endswith('json')]
    user_file_list = [i for i in user_file_list if i != username]
    return user_file_list


# 删除用户接口
def del_user(username):
    user_path = os.path.join(settings.DB_DIR, f'{username}.json')
    os.remove(user_path)

5.interface文件夹

user_interface.py

from lib import common
from db import db_handler

my_log = common.get_my_logger('用户相关记录')


# 注册接口
def register_interface(username, password, admin_num):
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    if user_dict:
        return False, f'{username}用户已被注册'
    # 调用加密
    hash_pwd = common.get_pwd(password)
    d1 = {
        'username': username,
        'password': hash_pwd,
        'balance': 15000,
        'shop_car': {},
        'bank_flow': [],
        'is_frozen': False,
        'is_admin': False
    }
    if admin_num == 'admin':
        d1['is_admin'] = True
    # 调用第三层保存
    db_handler.save(d1)
    if d1.get('is_admin'):
        my_log.info(f'管理员{username}注册成功')
        return True, f'【管理员】{username}，注册成功！'
    my_log.info(f'用户{username}注册成功')
    return True, f'【用户】{username}，注册成功'


# 登录接口
def login_interface(username, password):
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    if not user_dict:
        return False, [f'用户{username}不存在', '']
    # 调用加密
    hash_pwd = common.get_pwd(password)
    if not hash_pwd == user_dict.get('password'):
        return False, ['密码有误', '']
    if user_dict.get('is_frozen'):
        return False, ['账户已被冻结无法登录', '']
    if not user_dict.get('is_admin'):
        my_log.info(f'用户{username}登录成功')
        return True, [f'【用户】{username}登录成功', '']
    my_log.info(f'管理员{username}登录成功')
    return True, [f'【管理员】{username}登录成功', user_dict.get('is_admin')]

bank_interface.py

from lib import common
from db import db_handler
from conf import settings
import time

my_log = common.get_my_logger('金额相关记录')
ctime = time.strftime('%Y-%m-%d %X')


# 查看余额接口
def check_balance_interface(username):
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    my_log.info(f'用户{username}查看了自己的余额')
    return True, f"您当前余额为：{user_dict.get('balance')}"


# 提现金额接口
def withdraw_interface(username, target_money):
    # 调用查看数字是否为整数或小数功能
    flag, msg = common.get_money(target_money)
    if not flag:
        return False, msg
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    if msg * (1 + settings.SXF) > user_dict.get('balance'):
        return False, '账户余额不足'
    user_dict['balance'] -= msg * (1 + settings.SXF)
    user_dict['bank_flow'].append(f'{ctime}：用户提现{msg}元,扣手续费{msg * settings.SXF}元,账户余额{user_dict.get("balance")}元')
    # 调用第三层保存用户接口
    db_handler.save(user_dict)
    my_log.info(f'用户{username}提现了自己的金额')
    return True, f'用户提现{msg}元成功,扣手续费{msg * settings.SXF}元,账户余额{user_dict.get("balance")}元'


# 充值金额接口
def recharge_interface(username, target_money):
    # 调用查看数字是否为整数或小数功能
    flag, msg = common.get_money(target_money)
    if not flag:
        return False, msg
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    user_dict['balance'] += msg
    user_dict['bank_flow'].append(f'{ctime}：用户充值{msg}元,账户余额{user_dict.get("balance")}元')
    # 调用第三层保存用户接口
    db_handler.save(user_dict)
    my_log.info(f'用户{username}充值了自己的余额')
    return True, f'用户充值{msg}元成功,账户余额{user_dict.get("balance")}元'


# 转账金额接口
def transfer_interface(username, target_user, target_money):
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    target_user_dict = db_handler.select(target_user)
    if not target_user_dict:
        return False, '转账用户不存在'
    # 调用查看数字是否为整数或小数功能
    flag, msg = common.get_money(target_money)
    if not flag:
        return False, msg
    # 判断余额是否足够
    if msg > user_dict.get('balance'):
        return False, '账户余额不足 无法转账'
    user_dict['balance'] -= msg
    target_user_dict['balance'] += msg
    user_dict['bank_flow'].append(f'{ctime}：用户向{target_user}转账了{msg}元,账户余额{user_dict.get("balance")}元')
    target_user_dict['bank_flow'].append(f'{ctime}：收到用户{username}转来的{msg}元,账户余额{target_user_dict.get("balance")}元')
    # 调用第三层保存接口
    db_handler.save(user_dict)
    db_handler.save(target_user_dict)
    my_log.info(f'用户{username}向{target_user}转了账')
    return True, f'用户转账给{target_user}账户{msg}元成功,账户余额{user_dict.get("balance")}元'


# 查看流水接口
def check_bank_flow_interface(username):
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    if not user_dict.get('bank_flow'):
        return False, '账户暂无流水信息'
    my_log.info(f'用户{username}查看了自己的流水账单')
    return True, user_dict.get('bank_flow')

shop_interface.py

from lib import common
from db import db_handler
import time

my_log = common.get_my_logger('购物相关记录')
ctime = time.strftime('%Y-%m-%d %X')


# 添加购物车接口
def add_shop_car_interface(username):
    small_shop_car = {}
    goods_list = [
        ['鱼肉', 20],
        ['羊肉', 30],
        ['猪肉', 40],
        ['鸡肉', 50],
        ['鸭排', 60],
        ['牛肉', 70]]
    while True:
        for num, goods_info in enumerate(goods_list, start=1):
            print(f'商品编号：{num}  商品名称：{goods_info[0]}  商品单价：{goods_info[1]}')
        choice = input('输入要购买的商品编号(q退出)：').strip()
        if choice == 'q':
            # 调用第三层查询用户接口
            user_dict = db_handler.select(username)
            big_shop_car = user_dict.get('shop_car')
            for i, j in small_shop_car.items():
                if i in big_shop_car:
                    big_shop_car[i][0] += small_shop_car[i][0]
                else:
                    big_shop_car[i] = j
            user_dict['shop_car'] = big_shop_car
            # 调用第三层保存接口
            db_handler.save(user_dict)
            my_log.info(f'用户{username}添加了自己的购物车')
            return True, '用户添加购物车成功'
        if not choice.isdigit():
            print('编号有误')
            continue
        choice = int(choice)
        if choice not in range(1, len(goods_list) + 1):
            print('编号不存在')
            continue
        # 获取商品信息、商品名称、商品单价、购买数量
        goods = goods_list[choice - 1]
        goods_name = goods[0]
        goods_money = goods[1]
        goods_num = input(f'输入要购买的{goods_name}的数量：').strip()
        if not goods_num.isdigit():
            print('数量有误')
            continue
        goods_num = int(goods_num)
        if goods_name in small_shop_car:
            small_shop_car[goods_name][0] += goods_num
        else:
            small_shop_car[goods_name] = [goods_num, goods_money]
        print(f'当前购物车有：{small_shop_car}')


# 查看购物车接口
def check_shop_car_interface(username):
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    if not user_dict.get('shop_car'):
        return False, '您暂未购买任何商品'
    my_log.info(f'用户{username}查看了自己的购物车')
    return True, user_dict.get('shop_car')


# 结算购物车接口
def pay_shop_car_interface(username):
    money = 0
    # 调用第三层查询用户接口
    user_dict = db_handler.select(username)
    if not user_dict.get('shop_car'):
        return False, '您暂未购买任何商品'
    for i in user_dict.get('shop_car').values():
        money += i[0] * i[1]
    if money > user_dict.get('balance'):
        return False, '您的账户余额不足'
    user_dict['balance'] -= money
    user_dict['shop_car'] = {}
    user_dict['bank_flow'].append(f'{ctime}：用户消费{money}元,账户余额{user_dict.get("balance")}元')
    # 调用第三层保存用户接口
    db_handler.save(user_dict)
    my_log.info(f'用户{username}清空了自己的购物车')
    return True, f'今日消费{money}元,账户余额{user_dict.get("balance")}元'

admin_interface.py

from lib import common
from db import db_handler
import time

my_log = common.get_my_logger('管理员相关记录')
ctime = time.strftime('%Y-%m-%d %X')


# 获取用户文件名接口
def user_file_interface(username):
    # 调用第三层查看所有用户接口
    user_file_list = db_handler.check_user_file(username)
    return True, user_file_list


# 冻结账户接口
def frozen_user_interface(username, target_user):
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    target_user_dict['is_frozen'] = True
    # 调用第三层保存用户接口
    db_handler.save(target_user_dict)
    my_log.info(f'管理员{username}冻结了{target_user}账户')
    return True, f'用户{target_user}已被冻结'


# 解冻账户接口
def unfrozen_user_interface(username, target_user):
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    target_user_dict['is_frozen'] = False
    # 调用第三层保存用户接口
    db_handler.save(target_user_dict)
    my_log.info(f'管理员{username}解冻了{target_user}账户')
    return True, f'用户{target_user}已被解冻'


# 删除账户接口
def del_user_interface(username, target_user):
    # 调用第三层删除用户接口
    db_handler.del_user(target_user)
    my_log.info(f'管理员{username}删除了{target_user}账户')
    return True, f'用户{target_user}已被删除'


# 查看用户购物车接口
def admin_check_user_shop_car_interface(username, target_user):
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    if not target_user_dict.get('shop_car'):
        return False, f'用户{target_user}暂未购买任何商品'
    my_log.info(f'管理员{username}查看了{target_user}的购物车')
    return True, target_user_dict.get('shop_car')


# 清空用户购物车接口
def clear_user_shop_car_interface(username, target_user):
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    if not target_user_dict.get('shop_car'):
        return False, f'用户{target_user}未购买任何商品'
    target_user_dict['shop_car'] = {}
    # 调用第三层保存用户接口
    db_handler.save(target_user_dict)
    my_log.info(f'管理员{username}清空了{target_user}的购物车')
    return True, f'用户{target_user}购物车已被清空'


# 给用户加钱接口
def add_user_balance_interface(username, target_user, target_money):
    # 调用查看数字是否为整数或小数
    flag, msg = common.get_money(target_money)
    if not flag:
        return False, msg
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    target_user_dict['balance'] += msg
    target_user_dict['bank_flow'].append(f'{ctime}：收到管理员{username}转来的{msg}元,账户余额{target_user_dict.get("balance")}元')
    # 调用第三层保存用户接口
    db_handler.save(target_user_dict)
    my_log.info(f'管理员{username}给{target_user}加了{msg}元')
    return True, f'用户{target_user}账户加了{msg}元,余额{target_user_dict.get("balance")}元'


# 查看用户余额接口
def admin_check_user_balance_interface(username, target_user):
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    my_log.info(f'管理员{username}查看了{target_user}的余额')
    return True, f'用户{target_user}当前余额为：{target_user_dict.get("balance")}'


# 查看用户流水账单接口
def admin_check_user_bank_flow_interface(username, target_user):
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    if not target_user_dict.get('bank_flow'):
        return False, '账户暂无流水信息'
    my_log.info(f'管理员{username}查看了{target_user}的流水账单')
    return True, target_user_dict.get('bank_flow')


# 重置密码接口
def reset_pwd_interface(username, target_user, password):
    # 调用密码加密
    hash_pwd = common.get_pwd(password)
    # 调用第三层查询用户接口
    target_user_dict = db_handler.select(target_user)
    target_user_dict['password'] = hash_pwd
    # 调用第三层保存用户接口
    db_handler.save(target_user_dict)
    my_log.info(f'管理员{username}修改了{target_user}的密码')
    return True, f'用户{target_user}密码已改为：{password}'

6.lib文件夹

common.py

import logging
import logging.config
from conf import settings
import hashlib
from core import src


# 日志
def get_my_logger(name):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置
    logger1 = logging.getLogger(name)
    return logger1


# 加密
def get_pwd(pwd):
    md5 = hashlib.md5()
    md5.update(pwd.encode('utf8'))
    hash_pwd = md5.hexdigest()
    return hash_pwd


# 装饰器
def outer_plus(mode):
    def outer(func):
        def inner(*args, **kwargs):
            if src.is_login.get('username'):
                if mode == 'no':
                    res = func(*args, **kwargs)
                    return res
                else:
                    if src.is_login.get('is_admin'):
                        res = func(*args, **kwargs)
                        return res
                    else:
                        print('你不是管理员无法执行该功能')
            else:
                print('您未登录')
                src.login()

        return inner

    return outer


# 查看数字是否为整数或小数
def get_money(money):
    try:
        money = float(money)
    except Exception:
        return False, '必须输入整数或小数'
    else:
        return True, money