def register():
# 1.获取参数
# json_data = request.data
# dict_data = json_data.loads(json_data)
# 上面两句话可以写成一句话
# request.get_json()
# request.json,等价于上面一句话
dict_data = request.json
mobile = dict_data.get("mobile")
sms_code = dict_data.get("sms_code")
password = dict_data.get("password")
# 2.校验参数,为空校验
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 3.手机号格式校验
if not re.match("1[35789]\d{9}", mobile):
return jsonify(errno=RET.DATAERR, errmsg="手机号格式不正确")
# 4.根据手机号,去redis中取出短信验证码
try:
redis_sms_code = redis_store.get("sms_code:%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取短信验证码异常")
# 5.判断短信验证码是否过期
if not redis_sms_code:
return jsonify(errno=RET.NODATA, errmsg="短信验证码已过期")
# 6.删除redis的短信验证码
try:
redis_store.delete("sms_code:%s" % mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="删除短信验证码异常")
# 7.判断传入的短信验证码和redis中取出的是否一致
if sms_code != redis_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 8.创建用户对象,设置属性
user = User()
user.nick_name = mobile
user.mobile = mobile
# user.password_hash = jiami(password) user.mobile = mobile
# user.password_hash = password(password) user.mobile = mobile
user.password = password
# 9.保存用户到数据库mysql
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="用户注册失败")
# 10.返回响应
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
mobile = request.json.get("mobile")
password = request.json.get("password")
smscode = request.json.get("smscode")
print(smscode, "ddddddddddddddd")
if not all([mobile, password, smscode]):
return jsonify(erron=RET.NODATA, errmsg="信息不全")
# 获得手机验证码
smscode_redis = redis_store.get(mobile)
print(smscode_redis.decode())
if smscode_redis is None:
return jsonify(erron=RET.NODATA, errmsg="没有手机验证吗过期")
if smscode != smscode_redis.decode():
return jsonify(erron=RET.DATAERR, errmsg="手机验证码部正确")
user = User()
user.mobile = mobile
user.nick_name = mobile
user.password = password
db.session.add(user)
db.session.commit()
return jsonify(erron=RET.OK, errmsg="")
def register():
"""
注册
:return:
"""
# 1、获取参数
param_dict = request.json
mobile = param_dict.get("mobile", "")
smscode = param_dict.get("smscode", "")
password = param_dict.get("password", "")
# 2、检验
# 参数是否齐全
if not all([mobile, smscode, password]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 短信验证码是否正确
try:
# 获取短信验证码
real_sms_code = redis_store.get("SMS_" + mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取本地短信验证码失败！")
if not real_sms_code:
# 短息验证码过期
return jsonify(errno=RET.NODATA, errmsg="短信验证码失效")
# 校验
real_sms_code = real_sms_code.decode()
if smscode != real_sms_code:
return jsonify(errno=RET.DATAERR, errmsg="短信验证码错误")
# 删除短息验证码
try:
redis_store.delete("SMS_" + mobile)
except Exception as e:
current_app.logger.error(e)
# 3、保存数据
user = User()
user.mobile = mobile
user.nick_name = mobile
# 在User模型中对密码加密处理
# hash_password = generate_password_hash(password)
user.password = password
db.session.add(user)
try:
db.session.commit()
except Exception as e:
db.session.rollback() # 回滚
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="保存数据失败")
# 保持用户登录状态
session["user_id"] = user.id
# session["nick_name"] = user.nick_name
# session["mobile"] = user.mobile
# 4、返回响应
return jsonify(errno=RET.OK, errmsg="OK")
def register():
# 1.获取前端传过来的参数： mobile smscode password
mobile = request.json.get('mobile')
sms_code = request.json.get('smscode')
password = request.json.get('password')
# 2.获取redis中保存的短信验证码，判断是否过期
real_sms_code = redis_store.get('sms_code_' + mobile)
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg='短信验证码已过期')
# 3.判断输入的和redis中的短信验证码是否一致
print('短信码是否一致： ', sms_code, real_sms_code)
if sms_code != real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg='请输入正确的短信验证码')
# 4.创建一个用户， 来保存注册信息,持久化到数据库
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile # 昵称
user.last_login = datetime.now() # 获取当前时间
db.session.add(user)
db.session.commit()
print('持久化成功')
# 5.返回注册成功
return jsonify(errno=RET.OK, errmsg='注册成功')
def createsuperuser(name,
password): # 函数名对应 python manage 函数名(createsuperuser)
"""
通过配置自定义命令行的形式来创建管理员账户
:param name:
:param password:
:return:
"""
# 1. 参数校验 --> 接受的两个参数是来自命令行,而不是前端
if not all([name, password]):
print('参数不足')
# 初始化模型,标记管理员
user = User()
user.nick_name = name
user.mobile = name
user.password = password
# 标记是否是管理员
user.is_admin = True
try:
db.session.add(user)
db.session.commit()
except Exception as e:
db.session.rollback()
print(e)
print('添加成功')
def register():
mobile = request.json.get("mobile")
# 用户输入的手机验证码
smscode = request.json.get("smscode")
password = request.json.get("password")
# if not re.match("1[345678]\d{9}",mobile):
# return jsonify(errno = RET.PARAMERR,errmsg = "手机号码输入错误")
# 校验手机验证码
# 从redis里面获取数据里面缓存的手机验证码
redis_sms_code = redis_store.get("code_" + mobile)
if redis_sms_code != smscode:
return jsonify(errno=RET.PARAMERR, errmsg="验证码输入错误")
user = User()
user.mobile = mobile
user.nick_name = mobile
user.password = password
# datetime.now() 获取到当前的时间,存储到数据库
user.last_login = datetime.now()
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
# 把用户注册的数据设置给session
session["mobile"] = user.mobile
session["user_id"] = user.id
session["nick_name"] = user.mobile
return jsonify(errno=RET.OK, errmsg="注册成功")
def register():
# 用户输入的手机号
mobile = request.json.get("mobile")
# 用户输入的短信验证码
smscode = request.json.get("smscode")
# 用户输入的密码
password = request.json.get("password")
# 获取redis服务器里面存储的短信验证码
real_sms_code = redis_store.get("sms_code_" + mobile)
if not real_sms_code:
return jsonify(errno=RET.NODATA, errmsg="短信验证码已失效")
# 判断用户输入的短信验证码是否和服务器里面存储的一致
if smscode != real_sms_code:
return jsonify(errno=RET.PARAMERR, errmsg="请输入正确的短信验证码")
# 创建一个用户对象用来注册用户
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile
# 获取当前时间,用来记录注册时间
user.last_login = datetime.now()
# 网数据库进行持久化操作
db.session.add(user)
db.session.commit()
return jsonify(errno=RET.OK, errmsg="注册成功")
def createsupperuser(name, password):
"""
创建管理员用户
:param name:
:param password:
:return:
"""
if not all([name, password]):
print('参数不足')
return
# 拼凑数据库模型的字段
user = User()
user.mobile = name
user.nick_name = name
user.password = password
user.is_admin = True
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存数据失败')
def createsuperuser(name, password):
"""
使用命令创建管理员用户
-- python manage.py createsuperuser -n 用户名 -p 密码
:param name: 用户名
:param password: 密码
:return:
"""
# 判断参数数据是否存在
if not all([name, password]):
print("参数不齐")
return
# 实例化用户对象
from info.models import User
user = User()
# 保存数据
user.mobile = name
user.nick_name = name
user.password = password
user.is_admin = True
try:
# 数据库新增
mysql_db.session.add(user)
# 事务提交
mysql_db.session.commit()
#
print("创建成功")
except Exception as e:
print(e)
mysql_db.session.rollback()
def add_test_user(test):
# 定义用户容器
user_list = []
# for 循环创建1000个用户
for i in range(0, 1000):
user = User()
user.nick_name = "老王%d" % i
user.mobile = "138%08d" % i
user.password_hash = "pbkdf2:sha256:50000$sJiSYnJ2$b0ec6137bf92b37b7e3993c63ae6eff03237b9c3b3c3fcbe875e3321872862e2"
# 设置用户近31天的登录时间
user.last_login = datetime.now() - timedelta(
seconds=random.randint(0, 3600 * 24 * 31))
# 添加到容器中
user_list.append(user)
try:
db.session.add_all(user_list)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return "添加失败"
return "添加成功"
def add_test_user(test):
#定义用户列表容器
user_list = []
for i in range(0, 10000):
#创建用户对象
user = User()
#设置属性
user.nick_name = "137%08d" % i
user.mobile = "137%08d" % i
user.password_hash = "pbkdf2:sha256:50000$2MEUTpZk$271ff871ca43bfe1c36e930a7d66b8fc8c620e309c4dc187a7fcab229a7da9cf"
user.is_admin = False
#设置用户随机登陆时间,获取当前时间 - 31天随机描述, 得到31天的活跃用户
user.last_login = datetime.now() - timedelta(
seconds=random.randint(0, 3600 * 24 * 31))
#添加用户列表
user_list.append(user)
#添加到数据库
try:
db.session.add_all(user_list)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return "失败"
return "成功"
def register():
"""
1. 获取参数和判断是否有值
2. 从redis中获取指定手机号对应的短信验证码的
3. 校验验证码
4. 初始化 user 模型，并设置数据并添加到数据库
5. 保存当前用户的状态
6. 返回注册的结果
"""
# 获取用户输入的手机号
mobile = request.json.get("mobile")
# 获取用户输入的短信验证码
smscode = request.json.get("smscode")
# 获取用户输入的密码
password = request.json.get("password")
# 获取到redis服务器里面存储的短信验证码
real_sms_code = redis_store.get("sms_code_"+mobile)
# 判断redis服务器里存储的短信验证码是否过期
if not real_sms_code:
return jsonify(errno=RET.NODATA,errmsg="验证码已过期")
# 判断用户输入的短信验证码和redis服务器里面的短信验证码是否一致
if smscode != real_sms_code:
return jsonify(errno=RET.PARAMERR,errmsg='请输入正确的验证码')
# 创建一个用户对象用来注册用户
user = User()
user.mobile = mobile
user.password = password
user.nick_name = mobile #昵称
#获取当前的时间,用来注册
user.last_login = datetime.now()
# 往数据库进行持久化操作
db.session.add(user)
db.session.commit()
return jsonify(errno=RET.OK,errmsg="注册成功")
def add_test_users():
"""
添加测试用户
:return:
"""
import datetime
users = []
now = datetime.datetime.now()
for num in range(0, 10001):
try:
from info.models import User
from info import mysql_db
from manage import app
user = User()
user.nick_name = "%011d" % num
user.mobile = "%011d" % num
user.password_hash = "pbkdf2:sha256:50000$SgZPAbEj$a253b9220b7a916e03bf27119d401c48ff4a1c81d7e00644e0aaf6f3a8c55829"
user.create_time = now - datetime.timedelta(
seconds=random.randint(0, 2678400))
user.last_login = now - datetime.timedelta(
seconds=random.randint(0, 2678400))
users.append(user)
print(user.mobile)
except Exception as e:
print(e)
with app.app_context():
for i in range(0, 101):
start_index = i * 100
if i != 0:
start_index += 1
# mysql_db.session.add_all(users)
session_user = users[start_index:(i + 1) * 100 + 1]
mysql_db.session.add_all(session_user)
mysql_db.session.commit()
print('OK')
def add_test_user(test):
# 定义用户容器
user_list = []
# for循环创建1000个用户
for i in range(0, 1000):
# 创建用户对象,设置属性
user = User()
user.nick_name = "老王%d" % i
user.mobile = "138%08d" % i
user.password_hash = "pbkdf2:sha256:50000$c6pfEyE8$01d47af3ad401cdd4822091596c517a5fa781c346e0f85ef4348bd57fdf96176"
# 设置用户近31天的登陆时间
user.last_login = datetime.now() - timedelta(
seconds=random.randint(0, 3600 * 24 * 31))
# 添加到容器中
user_list.append(user)
# 添加到数据库
try:
db.session.add_all(user_list)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return "添加失败"
return "添加成功"
def add_test_users():
users = []
now = datetime.datetime.now()
for num in range(0, 10000):
try:
user = User()
user.nick_name = "%011d" % num
user.mobile = "%011d" % num
# user.password = password 实现密码加密存储
# 添加假密码，没有调用密码加密方法；
# user.psssword = '%011d' % num
user.password_hash = "pbkdf2:sha256:50000$SgZPAbEj$a253b9220b7a916e03bf27119d401c48ff4a1c81d7e00644e0aaf6f3a8c55829"
user.last_login = now - datetime.timedelta(
seconds=random.randint(0, 2678400))
users.append(user)
print(user.mobile)
except Exception as e:
print(e)
# 手动开启一个app的上下文
# with open('temp.json','w'):
# f.write(数据)
with app.app_context():
db.session.add_all(users)
db.session.commit()
print('OK')
def register():
mobile = request.json.get("mobile")
smscode = request.json.get("smscode")
password = request.json.get("password")
if not all([mobile,smscode,password]):
return jsonify(errno = RET.PARAMERR,errmsg = "请输入内容")
sms_code = redis_store.get("sms_code" + mobile)
print(sms_code)
if not sms_code:
return jsonify(errno = RET.DATAERR,errmsg = "验证码已过期")
if sms_code != smscode:
return jsonify(errno = RET.PARAMERR,errmsg = "验证码输入错误")
user = User()
user.nick_name = mobile
user.password = password
user.mobile = mobile
user.last_login = datetime.now()
db.session.add(user)
db.session.commit()
return jsonify(errno = RET.OK,errmsg = "注册成功")
def create_super_user(name, password):
"""创建管理员用户"""
if not all([name, password]):
return "参数不足"
user = User()
user.is_admin = True
user.nick_name = name
user.mobile = name
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
print("创建管理员失败")
print("创建管理员成功")
def add_test_users():
"""添加测试用户"""
users = []
# 获取当前时间
now = datetime.datetime.now()
for num in range(0, 10000):
try:
user = User()
user.nick_name = "%011d" % num
user.mobile = "%011d" % num
user.password_hash = "pbkdf2:sha256:50000$SgZPAbEj$a253b9220b7a916e03bf27119d401c48ff4a1c81d7e00644e0aaf6f3a8c55829"
# 2678400，一个月的秒数
# 当前时间 - 31天 = 9-11
# 当前时间 - 随机的秒 = 10月11 - 9月11号中，用户随机登录了
user.last_login = now - datetime.timedelta(
seconds=random.randint(0, 2678400))
users.append(user)
print(user.mobile)
except Exception as e:
print(e)
# 手动开启应用上下文
with app.app_context():
db.session.add_all(users)
db.session.commit()
print("OK")
def add_test_user(test):
# 用户容器
user_list = []
for i in range(0, 10000):
# 创建用户
user = User()
# 设置属性
user.nick_name = "老王%d" % i
user.mobile = "138%08d" % i
user.password_hash = "pbkdf2:sha256:50000$OfJMHM9l$a45e1cb75b5c010ddc329af10837637b2af93bf5fae510a4ec6a2f8377fdce66"
# 设置随机，设置最后登陆时间，在31天内的随机登陆时间
user.last_login = datetime.now() - timedelta(
seconds=random.randint(0, 3600 * 24 * 31))
# 添加用户到容器中
user_list.append(user)
print(i)
# 添加到数据库
try:
db.session.add_all(user_list)
db.session.commit()
except Exception as e:
return "添加失败"
return "添加成功"
def register():
mobile = request.json.get('mobile')
smscode = request.json.get('smscode')
password = request.json.get('password')
if not all([mobile,smscode,password]):
return jsonify(errno = RET.PARAMERR,errmsg = '请输入正确的参数')
# 注册
# 获取到redis数据库里面的短信验证码
real_sms_code = redis_store.get('sms_code_' + mobile)
if not real_sms_code:
return jsonify(errno = RET.NODATA,errmsg = '短信验证码已经过期')
if smscode != real_sms_code:
return jsonify(errno = RET.PARAMERR,errmsg = '请输入正确的短信验证码')
user = User()
user.nick_name = mobile
user.password = password
user.mobile = mobile
# 提交注册用户到数据库里面
db.session.add(user)
db.session.commit()
return jsonify(errno = RET.OK,errmsg = '注册成功')
def register():
"""
用户注册访问路径
用户点击注册按钮时
通过main.js中submit函数的ajax请求
"""
user_info = request.json
mobile = user_info.get('mobile')
sms_code = user_info.get('sms_code')
password = user_info.get('password')
try:
session_sms_code = redis_store.get('sms_code: %s' % mobile)
if session_sms_code:
if session_sms_code == sms_code:
new_user = User()
new_user.nick_name = mobile
new_user.password = password
new_user.mobile = mobile
try:
db.session.add(new_user)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,
errmsg=error_map[RET.DBERR])
db.session.commit()
return jsonify(errno=RET.OK, errmsg=error_map[RET.OK])
else:
return jsonify(errno=RET.DATAERR, errmsg='手机验证码有误')
else:
return jsonify(errno=RET.DATAEXIST, errmsg='验证码信息已过期, 请重新获取')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=error_map[RET.DATAERR])
def add_test_user(test):
#1.定义容器
user_list = []
#2.for循环创建1000个用户
for i in range(0, 1000):
user = User()
user.nick_name = "老王%s" % i
user.mobile = "138%08d" % i
user.password_hash = "pbkdf2:sha256:50000$aKqdryiI$c7a6e0e7f550cf8710def5eafda02fd36547d938bad71b8a40466830764aec6e"
#设置用户的登陆时间为近31天的
user.last_login = datetime.now() - timedelta(
seconds=randint(0, 3600 * 24 * 31))
user_list.append(user)
#3.将用户添加到数据库中
try:
db.session.add_all(user_list)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return "添加测试用户失败"
return "添加测试用户成功"
def register():
'''注册：向用户表中添加一条数据'''
# 1.接收
mobile = request.json.get('mobile')
sms_request = request.json.get('smscode')
password = request.json.get('password')
# 2.验证
# 2.1非空
if not all([mobile, sms_request, password]):
return jsonify(errno=RET.NODATA, errmsg='数据不完整')
# 2.2获取短信验证码
sms_redis = redis_store.get(mobile)
if sms_redis is None:
return jsonify(errno=RET.NODATA, errmsg='短信验证码过期')
# 2.3手机验证码是否正确
if sms_request != sms_redis.decode():
return jsonify(errno=RET.DATAERR, errmsg='验证码错误')
# 3.处理:向表中添加数据
user = User()
user.nick_name = mobile
user.mobile = mobile
user.password = password
# user.pasword(pwd)
db.session.add(user)
db.session.commit()
# 4.响应
return jsonify(errno=RET.OK, errmsg='')
def register():
"""
注册逻辑：
１．获取参数
２．校验参数
３．
:return:
"""
param_dict=json.loads(request.data)
# param_dict=request.json
mobile=param_dict.get('mobile')
smscode=param_dict.get('smscode')
password=param_dict.get('password')
if not all([mobile,smscode,password]):
return jsonify(errn=RET.PARAMERR,errmsg='参数错误')
if not re.match(r'1[3578]\d{9}',mobile):
return jsonify(errno=RET.DATAERR,errmsg='手机号错误')
try:
real_smscode=redis_store.get('mobilbe'+mobile)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR,errmsg='数据库查询错误')
if not real_smscode:
return jsonify(errno=RET.NODATA,errmsg='短信验证码不存在或失效')
if smscode!=real_smscode:
return jsonify(errno=RET.DATAERR,errmsg='短信验证码输入错误')
# 验证通过后，将用户数据保存到数据库中
user=User()
user.mobile=mobile
# 昵称初始化为手机号
user.nick_name=mobile
# 记录最后一次登录信息
user.last_login=datetime.now()
# 密码要加密保存
# 在模型定义中进行密码加密的实现
# 使用@property装饰器和@password.setter装饰器实现对密码的加密
user.password=password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR,errmsg='保存数据异常')
# 注册成功后，转为登录状态，将用户信息保存在session中
session['user_id']=user.id
session['mobile']=user.mobile
session['nick_name']=user.nick_name
# 返回注册成功状态
return jsonify(errno=RET.OK,errmsg='数据保存成功')
def createsuperuser(name, password):
"""创建管理员用户接口"""
if not all([name, password]):
return "参数不足"
# 创建用户对象
user = User()
# 昵称
user.nick_name = name
# 账号
user.mobile = name
user.password = password
# 设置为管理员
user.is_admin = True
# 保存回数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存管理员用户异常")
return "创建管理员用户成功"
def register():
mobile = request.json.get('mobile')
sms_code = request.json.get('sms_code')
password = request.json.get('password')
print(mobile, sms_code, password)
if not all([mobile, sms_code, password]):
return jsonify(errno=RET.PARAMERR, errmsg='请输入正确参数')
sms_code_redis_store = redis_store.get('sms_code_' + mobile)
if not sms_code_redis_store:
return jsonify(errno=RET.PARAMERR, errmsg='短信验证码已经过期')
if sms_code_redis_store != sms_code:
return jsonify(errno=RET.DATAERR, errmsg='请输入正确的短信校验码')
try:
redis_store.delete('sms_code_' + mobile)
except Exception as e:
current_app.logger.error(e)
user = User()
user.mobile = mobile
user.nick_name = mobile
user.password = password
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 注册便登陆
session['user_id'] = user.id
session['nick_name'] = user.nick_name
session['mobile'] = user.mobile
user.last_login = datetime.now()
return jsonify(errno=RET.OK, errmsg='注册成功')
def createSuperUser(username, password):
"""创建管理员用户方法"""
if not all([username, password]):
return "账号密码不能为空"
# 创建用户对象，并且给其属性赋值
user = User()
user.mobile = username
user.password = password
user.nick_name = username
# 标识用户为管理员
user.is_admin = True
# 保存到数据库
try:
db.session.add(user)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return "保存管理员用户失败"
return "创建管理员用户成功"
def add_test_users():
# 用户列表
users = []
# 当前时间
now = datetime.datetime.now()
# 生成10000个用户
for num in range(0, 10000):
try:
user = User()
user.nick_name = "%011d" % num
user.mobile = "%011d" % num
user.password_hash = "pbkdf2:sha256:50000$SgZPAbEj$a253b9220b7a916e03bf27119d401c48ff4a1c81d7e00644e0aaf6f3a8c55829"
# 用户活跃量 = 当前时间 - (0~31天中间的随机秒数) ：2018-12-5 ～ 2019-1-5 任意一个时间点登录
user.last_login = now - datetime.timedelta(
seconds=random.randint(0, 2678400))
users.append(user)
print(user.mobile)
except Exception as e:
print(e)
# 手动开启应用上下文
with app.app_context():
# 往数据库添加用户对象
db.session.add_all(users)
db.session.commit()
print('OK')
def create_test_user(test):
#定义用户容器
user_list = []
for i in range(0,1000):
#创建对象
user = User()
#设置属性 %08d表示输入8位数，不够的按照0来凑
user.nick_name = "150%08d"%i
user.mobile = "150%08d"%i
user.password_hash = 'pbkdf2:sha256:50000$JJDl1C8E$3074714998b4faf08d8493b2586734e57a892aefe78569b0060b2112404e0f4f'
user.is_admin = False
#模拟用户近一个月的登录时间 当前时间-随机时间
user.last_login = datetime.now() - timedelta(seconds=random.randint(0,3600*24*31))
#添加到容器
user_list.append(user)
#添加到数据库
try:
db.session.add_all(user_list)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return "添加失败"
return "添加成功"
def create_superuser(username, password):
if not all([username, password]):
print("参数不完整")
return
from info.models import User
from info import db
# 管理员(创建用户, is_admin=True)
user = User()
user.mobile = username
user.password = password
user.nick_name = username
user.is_admin = True
# 添加到数据库
try:
db.session.add(user)
db.session.commit()
except BaseException as e:
current_app.logger.error(e)
db.session.rollback()
print("数据库操作错误")
print("管理员创建成功")
