def execute_adding_data():
words_count = Word.query.count()
users_count = User.query.count()
if words_count > 0:
print('initial words loaded in database')
else:
for item in lexicon:
term = item.get("term")
meaning = item.get("meaning")
pronunciation = item.get("pronunciation")
category = item.get("category")
mnemonic_phrase = item.get("mnemonic_phrase")
new_word = Word(term, meaning, pronunciation, category,
mnemonic_phrase)
new_word.add()
print('words_added')
if users_count > 0:
print('initial users loaded in database')
else:
for item in users:
name = item.get("name")
lastname = item.get("lastname")
email = item.get("email")
password_user = item.get("password")
password = generate_password_hash(password_user, method='sha256')
avatar = create_avatar(name, lastname)
new_user = User(name, lastname, email, password, avatar)
new_user.add()
print('users_added')
def test_existing_user(self):
"""Test with an already existing user, try registering a user twice"""
res = User("desmond", "*****@*****.**", "pass1234")
res.add()
res2 = User("desmond", "*****@*****.**", "pass1234")
user = res2.add()
self.assertEqual(user, "Username Is already taken")
def create_admin_user(self, num=10):
role_lst = [
('会员管理员', RoleEnum.UserAdmin),
('日志管理员', RoleEnum.LogAdmin),
('影片管理员', RoleEnum.MovieAdmin),
('预告管理员', RoleEnum.PreviewAdmin),
('标签管理员', RoleEnum.TagAdmin),
]
for i in range(1, num + 1):
file_name = f'media\\avatar\\{random.randint(1, 43)}.jpg'
with open(file_name, 'rb') as f:
user = User()
form = RegisterForm()
intro, role = random.choice(role_lst)
form.name.data = f'admin{i}'
form.email.data = f'admin{i}@admin.com'
form.phone.data = '187' + ''.join(
str(random.randint(0, 9)) for _ in range(8))
form.avatar.data = FileStorage(f)
form.password.data = '123asd'
form.repassword.data = '123asd'
user.confirm = 1
user.intro = intro
user.auth = AuthEnum.Admin
user.role = role
user.add(form, record_log=False)
def post(self):
'''Method for signing up a user'''
args = SignupResource.parser.parse_args()
password = args.get('password')
username = args.get('username')
email = args.get('email')
email_format = re.compile(
r"(^[a-zA-Z0-9_.-]+@[a-zA-Z-]+\.[.a-zA-Z-]+$)")
username_format = re.compile(r"(^[A-Za-z0-9-]+$)")
if is_blank(password) or is_blank(username) or is_blank(email):
return {'message': 'All fields are required'}, 400
if not (re.match(username_format, username)):
return {'message' : 'Invalid username'}, 400
elif not (re.match(email_format, email)):
return {'message': 'Invalid email. Ensure email is of the form [email protected]'}, 400
if len(username) < 4:
return {'message' : 'Username should be atleast 4 characters'}, 400
if len(password) < 8:
return {'message' : 'Password should be atleast 8 characters'}, 400
username_exists = User.get('users', username=username)
email_exists = User.get('users', email=email)
if username_exists or email_exists:
return {'message': 'That username or email is taken.'}, 203
user = User(username=username, email=email, password=password)
user.add()
user= User.get('users', username=username)
return {'message': 'Successfully registered', 'user': User.user_dict(user)}, 201
def _callback() -> Response:
# Get authorization code Google sent back to you
code: str = request.args.get("code")
if not code:
return abort(400)
# Find out what URL to hit to get tokens that allow you to ask for
# things on behalf of a user
google_provider_cfg = get_google_provider_cfg()
token_endpoint = google_provider_cfg["token_endpoint"]
# Prepare and send a request to get tokens! Yay tokens!
token_url, headers, body = client.prepare_token_request(
token_endpoint,
authorization_response=request.url,
redirect_url=request.base_url,
code=code)
token_response = requests.post(
token_url,
headers=headers,
data=body,
auth=(GOOGLE_CLIENT_ID, GOOGLE_CLIENT_SECRET),
)
if token_response.json().get("access_token", None) is None:
return abort(400)
# Parse the tokens!
client.parse_request_body_response(json.dumps(token_response.json()))
# Now that you have tokens (yay) let's find and hit the URL
# from Google that gives you the user's profile information,
# including their Google profile image and email
userinfo_endpoint = google_provider_cfg["userinfo_endpoint"]
uri, headers, body = client.add_token(userinfo_endpoint)
userinfo_response = requests.get(uri, headers=headers, data=body)
# You want to make sure their email is verified.
# The user authenticated with Google, authorized your
# app, and now you've verified their email through Google!
if userinfo_response.json().get("email_verified"):
unique_id: str = userinfo_response.json()["sub"]
users_email: str = userinfo_response.json()["email"]
picture: str = userinfo_response.json()["picture"]
users_name: str = userinfo_response.json()["given_name"]
# update user's data each time user login
if User.get(unique_id) is None:
User.add(unique_id, users_name, users_email, picture)
else:
User.update(unique_id, users_name, users_email, picture)
# Login user
user: User = User(unique_id, users_name, users_email, picture)
login_user(user)
return redirect(request.host_url)
else:
return abort(400,
"User email not available or not verified by Google.")
def register():
myForm = LoginForm(request.form)
if request.method == "POST":
user = User(myForm.username.data, myForm.password.data)
user.add()
return redirect(url_for('main'))
else:
return render_template('register.html', form=myForm)
def test_view_all_users(self):
"""Test view all users"""
res = User("desmond", "*****@*****.**", "pass1234")
res.add()
res2 = User("desmond", "*****@*****.**", "pass1234")
user = res2.add()
count = len(self.user.fetch_all())
self.assertEqual(count, 2)
def register_user(username, password, email, will_contact):
user = User(username=username,
password=User.set_password(User, password),
email=email,
will_contact=will_contact)
User.add(User, user)
return {'id': user.id}
def register():
if current_user.is_authenticated:
return redirect(url_for('main_bp.index'))
form = RegisterForm()
if form.validate_on_submit():
User.add(form.username.data, form.password.data,
form.phone_number.data)
flash('注册成功，请登录。')
return redirect(url_for('.login'))
return render_template('auth/register.html', form=form)
def post(self):
user_data_json = request.get_json(force=True)
title = user_data_json['title']
description = user_data_json['description']
try:
user = User("Title 3", "Description")
user.add(user)
return {"result": "Successful"}
except:
return {"result": "Error"}
def admin_add():
form = AdminForm()
if form.validate_on_submit():
user = User()
user.auth = AuthEnum.Admin
user.confirm = 1
user.intro = RoleEnum.role_str(form.role.data)
user.add(form, record_log=False)
return redirect(url_for('auth.admin_add'))
return render_template('admin/admin_add.html', form=form)
def signup():
if request.method == "POST":
form - LoginForm()
user= User()
fname = request.form['fname']
lname = request.form['lname']
email = request.form['email']
password = request.form['password']
user.add(fname,lname, email, password)
return redirect(url_for("auth_bp.main"))
else:
return render_template("signup.html", title ="register")
def post(self):
"""注册接口"""
parser = reqparse.RequestParser()
parser.add_argument('loginName', type=str, required=True)
parser.add_argument('password', type=str)
parser.add_argument('type', type=int)
args = parser.parse_args()
if User.query.filter_by(loginName=args.loginName).first():
raise RegisterFailed()
user = User()
user.loginName = args.loginName
user.password = args.password
user.type = args.type
user.add()
return {}, 200
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegistrationForm()
if form.validate_on_submit():
User.add({
"name": form.name.data,
"address": form.address.data,
"email": form.email.data,
"password": form.password.data
})
flash('You were successfully registered !', "success")
return redirect(url_for('login.login'))
return render_template('register.html', title='Register', form=form)
def add_user(req):
u = User()
u.get(req)
try:
return u.add()
except ValueError as e:
return {'fname': 'add_user', 'err': e, 'data': req}
def authorize():
# getting auth data from google
google = oauth.create_client("google")
token = google.authorize_access_token()
resp = google.get('userinfo')
user_info = resp.json()
# setting values to session storage
session["email"] = user_info["email"]
session["user_id"] = user_info["id"]
# adding user if he is not present in users table
if not User.find_by_id(user_info["id"]):
User.add(User(id=user_info["id"], name=user_info["name"], email=user_info["email"]))
return redirect('/auth/status')
def test_should_add_user(self):
username = '******'
password = '******'
user = User()
self.assertEqual(user.add(username, password), True)
user.delete(username)
def test_should_not_add_already_registered_user(self):
username = '******'
password = '******'
user = User()
self.assertEqual(user.add(username, password), True)
self.assertEqual(user.add(username, password), False)
user.delete(username)
def create_super_admin(self):
if User.query.filter_by(email='*****@*****.**').first():
return
file_name = f'media\\avatar\\{random.randint(1, 43)}.jpg'
with open(file_name, 'rb') as f:
user = User()
form = RegisterForm()
form.name.data = 'super_admin'
form.email.data = '*****@*****.**'
form.phone.data = '98765432121'
form.avatar.data = FileStorage(f)
form.password.data = '123asd'
form.repassword.data = '123asd'
user.confirm = 1
user.intro = 'super admin'
user.auth = AuthEnum.SuperAdmin
user.role = RoleEnum.SuperAdmin
user.add(form, record_log=False)
def create_user(self, num=50):
for i in range(1, num + 1):
file_name = f'media\\avatar\\{random.randint(1, 43)}.jpg'
with open(file_name, 'rb') as f:
user = User()
form = RegisterForm()
form.name.data = f'test{i}'
form.email.data = f'test{i}@test.com'
form.phone.data = '131' + ''.join(
str(random.randint(0, 9)) for _ in range(8))
form.avatar.data = FileStorage(f)
form.password.data = '123asd'
form.repassword.data = '123asd'
user.confirm = 1
user.intro = 'normal user'
user.auth = AuthEnum.User
user.role = RoleEnum.User
user.add(form, record_log=False)
def register():
data = json.loads(request.data.decode())
username = data['username']
password = data['password']
user = User()
was_added = user.add(username, password)
return jsonify(was_added=was_added), 200
def register():
data = request.get_json() or {}
if 'username' not in data or 'email' not in data or 'password' not in data:
return bad_request('must include username, email and password fields')
if User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user = User()
user.from_dict(data)
user.add()
session_commit()
if user.id:
data = user.to_dict()
response = trueReturn(data, '用户注册成功')
# response.status_code = 201
return response
else:
return bad_request('用户注册失败')
def register():
if current_user.is_authenticated:
logout_user()
form = RegisterForm()
if form.validate_on_submit():
user = User()
if not user.add(form, record_log=False):
return redirect(url_for('auth.register'))
return redirect(url_for('auth.login'))
return render_template('auth/register.html', form=form)
def user():
user = User()
user.username = '******'
user.role_id = 2
user.email = '*****@*****.**'
user.phone = '0921111111'
user.add = 'sfsfsdfsafsdfsfasfsfa'
user.password_hash = generate_password_hash('1111', method="pbkdf2:sha1")
user.is_admin = False
user.confirmed = True
db.session.add(user)
db.session.commit()
def admin():
user = User()
user.username = '******'
user.role_id = 1
user.email = '*****@*****.**'
user.phone = '0921111111'
user.add = 'sdfdsfsdfsdfsd'
user.password_hash = generate_password_hash('1111', method="pbkdf2:sha1")
user.is_admin = True
user.confirmed = True
db.session.add(user)
db.session.commit()
def admin():
if g.current_user.role.name != 'Administrator':
return forbidden("没有足够权限")
if request.method == 'GET':
return User.get(g.current_user.store_id, **request.args)
elif request.method == 'POST':
return User.add(g.current_user.store_id, **request.json)
elif request.method == 'DELETE':
return User.delete(g.current_user.store_id, **request.args)
elif request.method == 'PUT':
return User.update(g.current_user.store_id, **request.json)
elif request.method == 'PATCH':
return User.reset_password(g.current_user.store_id, **request.json)
def add_employee():
if not current_user.is_authenticated:
return redirect(url_for('login'))
form = AddEmployeeForm()
if form.validate_on_submit():
user = User()
create = user.add(form.first_name.data, form.last_name.data, form.password.data, form.email.data, form.user_role.data, form.active.data)
if create:
flash("New employee created with the username %s" % form.email.data)
return redirect(url_for('list_employees'))
else:
flash('Employee creation failed.')
return render_template('employees/add.html', title='Add an Employee | Medifax', form=form)
def add_users_and_workstations(text):
data = []
if text:
result = parse_users_and_workstations(text)
for r in result:
user_id = User.add(username=r[0])
workstation_id = Workstation.add(workstation=r[1])
date_4_db = datetime(datetime.now().year, r[7], r[8], r[9], r[10])
data.append({
'user_id': user_id,
'workstation_id': workstation_id,
'time_out': date_4_db
})
return data
def post(self):
"""
注册
"""
args = parse_base.parse_args()
password = args.get('password')
action = args.get('action').lower()
# 注册
if action == USER_ACTION_REGISTER:
args_register = parse_register.parse_args()
username = args_register.get('username').lower()
email = args_register.get('email')
phone = args_register.get('phone')
if get_user(username):
abort(RET.BadRequest, msg='用户名已注册')
if get_user(phone):
abort(RET.BadRequest, msg='手机号码已注册')
if get_user(email):
abort(RET.BadRequest, msg='邮箱已注册')
user = User()
user.username = username
user.password = password
user.email = email
user.phone = phone
if user.add():
data = {'status': RET.Created, 'msg': '注册成功', 'data': user}
return marshal(data, sing_user_fields)
abort(RET.BadRequest, msg='注册失败')
# 登录
elif action == USER_ACTION_LOGIN:
args_login = parse_login.parse_args()
username = args_login.get('username').lower()
user = get_user(username)
if not user:
abort(RET.BadRequest, msg='用户名或密码错误')
if (not user.check_pwd(password)) or user.is_del != '0':
abort(RET.Unauthorized, msg='用户名或密码错误')
token = uuid.uuid4().hex
cache.set(token, user.id, timeout=60 * 60 * 7)
data = {'status': RET.OK, 'msg': '登录成功', 'token': token}
return data
else:
abort(RET.BadRequest, msg='参数错误，请检查后重试')
def register():
"""A route to handle user registration"""
data = request.get_json()
print(data['username'])
# validate the data
res = validdate_data(data)
check_pass = validate_password(data)
if res is not "valid":
return jsonify({"message": res}), 400
elif check_pass is not "valid":
return jsonify({"message": check_pass}), 400
else:
try:
username = data['username']
email = data['email']
password = data['password']
user = User(username, email, password)
res = user.add()
return jsonify({"message": "Registered Successfully", "response": res}), 201
except Exception as error:
# an error occured when trying to register the user
response = {'message': str(error)}
return jsonify(response), 401
