def add_user():
"""
添加新用户
:return:
"""
username = request.forms.username
password = request.forms.password
nickname = request.forms.nickname
status = request.forms.status
create_time = datetime.datetime.now()
# 加密密码
password = hashlib.md5(password.encode("UTF-8")).hexdigest()
# 检测用户名是否存在
if UserModel.select().where(UserModel.username == username,
UserModel.status != 2).count():
return {"code": -1}
user = UserModel(username=username,
password=password,
nickname=nickname,
status=status,
create_time=create_time)
user.save()
return {"code": 0}
def _post_edit(self):
profile = {}
profile["email"] = self.get_body_argument("email", default=None)
profile["website"] = self.get_body_argument("website", default=None)
profile["qq"] = self.get_body_argument("qq", default=None)
profile["address"] = self.get_body_argument("address", default=None)
profile["signal"] = self.get_body_argument("signal", default=None)
orgpass = self.get_body_argument("orgpass", default=None)
if orgpass:
password = self.get_body_argument("password")
repassword = self.get_body_argument("repassword")
if not password or len(password) < 5:
self.custom_error("新密码太短")
if password != repassword:
self.custom_error("两次输入的密码不相同")
user = yield self.db.member.find_one(
{"username": self.current_user["username"]})
check = yield self.backend.submit(hash.verify, orgpass,
user["password"])
if not check:
self.custom_error("原始密码输入错误")
profile["password"] = yield self.backend.submit(hash.get, password)
if profile["email"].endswith('@tjchtech.com'):
self.custom_error("由于邮件域名问题，不能使用公司邮箱")
# check user profile
model = UserModel()
if not model(profile):
self.custom_error(model.error_msg)
yield self.db.member.update(
{"username": self.current_user["username"]}, {"$set": profile})
self.redirect("/user/edit")
def post(self, gameKey: int) -> Response:
payload: dict = request.json
game: GameModel = GameModel.objects(game_key=gameKey).first()
if not game:
return Response('', 204)
user: UserModel = UserModel.objects(user_id=payload['id'],
game=game).first()
if user:
if check_password_hash(user.password, payload['password']):
return jsonify({
'accessToken':
create_access_token(payload['id'],
expires_delta=timedelta(days=10))
})
else:
return Response('', 205)
default_team: TeamModel = TeamModel.objects(game=game,
team_id=0).first()
UserModel(game, payload['id'], payload['email'],
generate_password_hash(payload['password']),
default_team).save()
return jsonify({
'accessToken':
create_access_token(payload['id'],
expires_delta=timedelta(days=10))
})
def post(self):
''' 创建用户 '''
args = self.jsondata
if not args:
return send_msg('fail', '无json数据')
if not args.name:
return send_msg('fail', '无参数name')
if not args.password:
return send_msg('fail', '无参数password')
if not args.email:
return send_msg('fail', '无参数email')
user = UserModel.query.filter_by(name=args.name).first()
if user:
return send_msg('fail', '用户名已被占用')
newuser = UserModel(args.name, args.password, args.email)
db.session.add(newuser)
dbflag, dbmsg = db_write()
if dbflag:
return send_msg('dberror', dbmsg)
userlog(self.resourcename, '新建用户:' + args.name, 'succ')
return send_msg('succ')
def post(self):
data = request.get_json()
print("\n")
print("Login Data:\n")
print(data)
print("\n")
hashed_password = generate_password_hash(data['password'],
method='sha256')
new_user = UserModel(public_id=str(uuid.uuid4()),
name=data['name'],
username=data['username'],
email=data['email'],
password=hashed_password,
admin=False)
db.session.add(new_user)
db.session.commit()
return jsonify({'message': 'User successfully created.'}, {
'public_id': new_user.public_id,
'name': new_user.name,
'username': new_user.username,
'email': new_user.email,
'admin': new_user.admin
})
def on_get(self, req, resp, id):
#"""GET ALL USERS WHO HAVE A INTEREST""
db = MySQLdb.connect(host="localhost",
user="******",
passwd="123456",
db="processodesoftware",
charset="utf8",
use_unicode=True)
cursor = db.cursor()
resp.status = falcon.HTTP_200 # Ok!
id = int(id)
#Executa a query
sql = "SELECT id_user FROM user_interests WHERE id_skill = %s" % (id)
cursor.execute(sql)
#Recebe todos os resultados
query = cursor.fetchall()
#Cria uma lista guardar os dados convertidos
queryObjects = []
#Converte
for q in query:
id = int(q[0])
#Executa a query
sql = "SELECT id, nome, email, idade FROM users WHERE id = %d" % (
id)
cursor.execute(sql)
#Recebe todos os resultados
query = cursor.fetchall()
#Converte
user = UserModel(query[0][0], query[0][1], query[0][2],
query[0][3])
queryObjects.append(user.__dict__)
resp.body = json.dumps(queryObjects)
db.close()
def _post_addadmin(self):
userid = self.get_body_argument('userid', default='')
password = self.get_body_argument('password', default='')
repassword = self.get_body_argument('repassword', default='')
# 两次输入的密码不匹配
if password != repassword:
self._json('fail', '两次密码不匹配')
# 密码长度太短
if len(password) < 6:
self._json('fail', '密码设置过短')
# 加密密码
password = yield self.backend.submit(hash.get, password)
oldadmin = yield self.db.admin.find_one({'userid': userid})
# 用户id已存在
if oldadmin:
self._json('fail', '用户id已存在, 请更换')
# 添加用户
user = {
'userid': userid,
'password': password,
'power': 20,
'registertime': time.time(),
'faceurl': '/static/assets/img/user04.png'
}
model = UserModel()
if not model(user):
self._json('fail', model.error_msg)
result = yield self.db.admin.insert(user)
self._json('success')
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'This user is already exists'}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully"}, 201
def on_get(self, req, resp, id):
#"""GET"""
db = MySQLdb.connect(host="localhost",
user="******",
passwd="123456",
db="processodesoftware",
charset="utf8",
use_unicode=True)
cursor = db.cursor()
resp.status = falcon.HTTP_200 # Ok!
id = int(id)
#Executa a query
sql = "SELECT id, nome, email, idade FROM users WHERE id = %d" % (id)
cursor.execute(sql)
#Recebe todos os resultados
query = cursor.fetchall()
#Cria uma lista guardar os dados convertidos
queryObjects = []
#Converte
for q in query:
cursor.execute(
"SELECT s.id, s.name FROM user_interests ui JOIN skills s ON ui.id_skill = s.id WHERE ui.id_user = %d"
% q[0])
interests = cursor.fetchall()
cursor.execute(
"SELECT s.id, s.name FROM user_skills us JOIN skills s ON us.id_skill = s.id WHERE us.id_user = %d"
% q[0])
skills = cursor.fetchall()
user = UserModel(q[0], q[1], q[2], q[3], "", interests, skills)
queryObjects.append(user.__dict__)
resp.body = json.dumps(queryObjects)
db.close()
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {'message': 'that username already exist'}, 400
user = UserModel(**data) #(data['username'], data['password'])
user.add_to_db()
return {'message': 'user registered successfully'}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "A user with that name already exists."}, 400
user = UserModel(**data)
user.save_to_db()
return {"message": "User created successfully."}, 201
def post(self):
project = UserRegister.parser.parse_args()
if UserModel.find_by_username(project['username']):
return {'message':'A user with this username is already exist'}, 400
user = UserModel(**project)
user.save_to_db()
return {"Message": "User created successfully"}, 201
def post(self):
reqdata=UserRegister.parser.parse_args()
existinguser=UserModel.find_by_username(reqdata['username'])
print("reqdata is: ",reqdata)
if existinguser:
return ({'message':'user already exists'},400)
newuser=UserModel(reqdata['username'],reqdata['password'])
newuser.save_to_db()
return ({'message':'user registered successfully'},201)
def register():
user_name = request.values['userName']
password = request.values['password']
if UserModel.find_by_username(user_name):
return {"message": USER_ALREADY_EXIT}, 400
user = UserModel(user_name, password)
user.save_to_db()
return {"message": USER_OP.format("created")}, 201
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {"message": "A user with that username already exsits"}, 400
user = UserModel(data["username"], data["password"])
user.save_to_db()
return {"message": "User created successfully"}, 201
def _checkusername_action(self):
username = self.get_body_argument("username", default=None)
user = {"username": username}
model = UserModel()
if not model(user):
self._json("fail", model.error_msg)
user = yield self.db.member.find_one({"username": username})
if user:
self._json("fail", "用户名已存在")
else:
self._json("success")
def post(self):
data = arguments.parse_args()
if UserModel.findByLogin(data['login']):
return BadRequest('The informed login already exists.')
if UserModel.findByEmail(data['email']):
return BadRequest('The informed email already exists.')
user = UserModel(**data)
user.activated = False
user.save()
user.send_confirmation_email()
return user.json(), 201
def Login(self):
uname = self.Post('uname')
passwd = self.Post('passwd')
# 验证用户名
if not Safety.IsRight('uname',uname) and not Safety.IsRight('tel',uname) and not Safety.IsRight('email',uname):
return self.GetJSON({'code':4000, 'msg':'请输入用户名/手机/邮箱'})
# 密码长度
if not Safety.IsRight('passwd',passwd) :
return self.GetJSON({'code':4000, 'msg':'请输入6~16位密码'})
# 查询
model = UserModel()
model.Table('user AS a')
model.LeftJoin('user_info AS b', 'a.id=b.uid')
model.LeftJoin('api_perm AS c', 'a.id=c.uid')
model.LeftJoin('api_role AS d', 'c.role=d.id')
model.Where(
'(a.uname=%s OR a.tel=%s OR a.email=%s) AND a.password=%s',
uname, uname, uname, Hash.Md5(passwd)
)
model.Columns('a.id', 'a.state', 'b.position', 'b.nickname', 'b.name', 'b.gender', 'b.birthday', 'b.img', 'c.perm', 'd.perm as role_perm')
data = model.FindFirst()
# 是否存在
if not data : return self.GetJSON({'code':4000, 'msg':'帐号或密码错误!'})
# 是否禁用
if data['state']!='1' : return self.GetJSON({'code':4000, 'msg':'该用户已被禁用!'})
# 权限
perm = data['role_perm']
if data['perm'] : perm=data['perm']
if not perm : return self.GetJSON({'code':4000, 'msg':'该用户不允许登录!'})
redis = Redis()
key = Env.api_token_prefix+'_perm_'+str(data['id'])
redis.Set(key, perm)
redis.Expire(key, Env.api_token_time)
redis.Close()
# 登录时间
model.Table('user')
model.Set({'ltime': Util.Time()})
model.Where('id=%s', data['id'])
model.Update()
# 返回
return self.GetJSON({
'code': 0,
'msg': '成功',
'token': ApiToken.Create({'uid':str(data['id']), 'uname':uname}),
'uinfo': {
'uid': data['id'],
'uname': uname,
'position': data['position'],
'nickname': data['nickname'],
'name': data['name'],
'gender': data['gender'],
'img': Env.base_url+data['img'] if data['img']!='' else '',
}
})
def post(self):
data_load = request.get_json()
try:
data = UserSchema().load(data_load)
except ValidationError as err:
return err.messages, 404
if UserModel.find_by_username(data["username"]) is None:
user = UserModel(data["username"], data["password"])
user.add_user()
return {"response": "The user was successfuly created"}, 201
else:
return dict(error="User with this username already exist"), 500
def post(self):
data = User.parser.parse_args()
user = UserModel.find(data["username"])
if user:
return {
"message": "User {} already exists".format(data["username"])
}, 400
user = UserModel(**data)
user.save()
return {"message": "User added"}, 201
def post(self):
payload = request.json
for key in ['id', 'password']:
if key not in payload:
abort(400)
if UserModel.objects(id=payload['id']).first():
return Response('', 204)
UserModel(id=payload['id'], pw=payload['password']).save()
return Response('', 201)
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"message": "User already exists."}
i = UserModel(**data)
try:
i.save_to_db()
except:
return {
"message": "An error occurred."
}, 500 # code for internal error
return {"message": "User created successfully."}, 201
def __init__(self, number):
self.number = number
self.db = db_test
self.user = UserModel(self.db)
self.group = GroupModel(self.db)
self.article = ArticleModel(self.db)
self.admin = {
'email': '*****@*****.**',
'penname': 'wutong',
'password': '******',
}
self.gen_test_data()
def post(self):
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data["username"]):
return {
"message":
"A user with this username already exists in the database!"
}, 400
user = UserModel(**data)
user.save_to_db()
return {
"message":
f"user {data['username']} has been created successfully!!"
}
def post(self):
"""
添加用户
serializer.Response
"""
parser = reqparse.RequestParser()
parser.add_argument('username',
type=str,
help='Username',
location="json")
parser.add_argument('password',
type=str,
help='Password',
location="json")
parser.add_argument('email', type=str, help='Email', location="json")
args = parser.parse_args()
username = args.get("username", None)
password = args.get("password", None)
email = args.get("email", None)
if ((username is None) or (password is None) or
(email is None)) and (18 < len(username) < 4):
return serializer.Response(serializer.USER_INPUT_ERROR, None,
"输入参数不合法 (可能是用户名长度不正确哦.)").Return()
# 检查用户名是否存在
temp = UserModel.query.filter_by(username=username).first()
if temp is not None:
return serializer.Response(serializer.USER_EXIST_ERROR, None,
"用户名已存在").Return()
# 检查邮箱是否已经被注册
temp = UserModel.query.filter_by(email=email).first()
if temp is not None:
return serializer.Response(serializer.USER_EXIST_ERROR, None,
"该邮箱已被使用").Return()
# 防止写入数据库出错.
try:
user = UserModel().create(username=username,
password=password,
email=email,
is_admin=False)
db.session.add(user)
db.session.commit()
except sqlalchemy.exc.IntegrityError as e:
return serializer.Response(serializer.SERVER_DATABASE_ERROR,
e.args, "用户创建失败!").Return()
return serializer.Response(0, None, "用户创建成功!").Return()
def post(self):
data = Usersignup.parser.parse_args()
if UserModel.get_user_by_name(data['username']):
return {
"message": "User already exists please enter new username"
}, 400
# conn = sqlite3.connect('user.db')
# cursor = conn.cursor()
# cursor.execute("Insert into user values(NULL, ?,?)",(data['username'],data['password']))
# conn.commit()
# conn.close
user = UserModel(**data)
user.save_to_db()
return {"message": "User is created successfully"}, 201
def post(self):
"""
:endpoint: /register
:post body: {"username":<username>, "password":<password>}
:return: Create successful or not.
:rtype: JSON Message.
"""
data = UserRegister.parser.parse_args()
if UserModel.find_by_username(data['username']):
return {"Message": 'The user name has already exists !'}, 400
user = UserModel(**data)
user.save_to_db()
return {"Message": "User created successful!"}, 201
def setUpClass(cls):
cls.db = util.db_test
cls.tearDownClass()
cls.model = UserModel(util.db_test)
cls.email = '*****@*****.**'
cls.penname = 'test'
cls.password = '******'
sql = '''insert into "user"
(email, penname, password)
values (%s, %s, crypt(%s, gen_salt('bf')))
returning uid,
md5(CAST(uid AS varchar)) AS "hashuid"'''
row = cls.db.getrow(sql, cls.email, cls.penname, cls.password)
cls.uid = row[0]
cls.hashuid = row[1]
def on_get(self, req, resp):
#"""GET"""
db = MySQLdb.connect (host = "localhost",user = "******",passwd = "123456",db = "processodesoftware")
cursor = db.cursor()
resp.status = falcon.HTTP_200 # Ok!
#Executa a query
cursor.execute("SELECT id, nome, email, idade FROM users")
#Recebe todos os resultados
query = cursor.fetchall()
#Cria uma lista guardar os dados convertidos
queryObjects = []
#Converte
for q in query:
user = UserModel(q[0], q[1], q[2], q[3])
queryObjects.append(user.__dict__)
resp.body = json.dumps(queryObjects)
db.close()
def on_post(self, req, resp):
email = req.media['email']
password = req.media['password']
if not password:
resp.status = falcon.HTTP_400
resp.body = "Password cannot be emptied!"
if not UserModel.objects(email=email):
hashPassword = bcrypt.hashpw(bytes(password, encoding='utf-8'),
bcrypt.gensalt())
newUser = UserModel(email=email, password=hashPassword)
newUser.save()
resp.status = falcon.HTTP_201
resp.body = "Your account has been created!"
else:
resp.status = falcon.HTTP_400
resp.body = "The email has been used!"
