def setUp(self):
super().setUp()
self.session.begin_nested()
self.commentor = User(name="Commentor", email="*****@*****.**")
self.author = User(name="Author", email="*****@*****.**")
self.post = Post(title="Test Post",
body="Test Post",
user_id=self.author.id)
self.answer = Answer(post_id=self.post.id, user_id=self.author.id)
self.author.posts.append(self.post)
self.author.answers.append(self.answer)
self.post.answers.append(self.answer)
self.session.add(self.commentor)
self.session.add(self.author)
self.session.add(self.post)
self.session.add(self.answer)
self.session.commit()
with self.client as c:
with c.session_transaction() as sess:
set_session_user(self.commentor, current_session=sess)
g.user = self.commentor
def test_verify_confirmation_token(self):
u = User(name='ose', password='******', email='*****@*****.**')
u2 = User(name='john', password='******', email='*****@*****.**')
token = u.generate_confirmation_token()
token2 = u2.generate_confirmation_token()
obj = u.validate_confirmation_token(token)
obj2 = u.validate_confirmation_token(token2)
self.assertTrue(obj)
def setUp(self):
super().setUp()
user = User(username='******', email='*****@*****.**', password='******')
user2 = User(username='******', email='*****@*****.**', password='******')
self.db.session.add(user)
self.db.session.add(user2)
self.db.session.commit()
self.userId = user.id
self.username = user.username
self.userEmail = user.email
self.user2name = user2.username
def setUp(self):
super().setUp()
user1 = User(username='******', email='*****@*****.**', password='******')
user2 = User(username='******', email='*****@*****.**', password='******')
self.db.session.add(user1)
self.db.session.add(user2)
self.db.session.commit()
post = Post(title="title", body="body", poster_id=user1.id)
self.db.session.add(post)
self.db.session.commit()
self.user1Id = user1.id
self.user2Id = user2.id
self.postId = post.id
def signup(self):
"""
Client:
- Payload: { "command": "user/signup", "params" : {email, password} }
Server:
- { "code" : 200, "data": {"rent": "0.37"}, "actions" : [] }
"""
email = self._json_data['email']
password = self._json_data['password']
existing_user = User.where('email', '=', email).first()
if existing_user is None:
user = User()
user.generate_token()
user.email = email
user.set_password(password)
# @TODO: write universal validator helper
values_to_save = self.left_keys(self._json_data,
{'first_name', 'last_name'})
for key, val in values_to_save.items():
setattr(user, key, val)
user.save()
if user.add_role_group('api'):
self.make_response(user.format_default())
else:
raise Exception('cant create user role.')
else:
self.make_message('User with such email already exists.')
def test_request_reset_password(client, db):
# Creates a new user
TEST_RESET_USER = '******'
TEST_RESET_PASSWORD = '******'
new_user = User(username=TEST_RESET_USER)
new_user.set_password(TEST_RESET_PASSWORD)
db.session.add(new_user)
db.session.commit()
# Logs in to user and add an email address and log out
login_response = login(client, TEST_RESET_USER, TEST_RESET_PASSWORD)
assert login_response.status_code == 200
assert b'dashboard' in login_response.data
MAIL_CREDS = get_server_mail_cred()
TEST_EMAIL_ADDRESS = MAIL_CREDS[2]
TEST_EMAIL_PASSWORD = MAIL_CREDS[3]
response = add_mail(client, TEST_EMAIL_ADDRESS, TEST_EMAIL_PASSWORD)
assert response.status_code == 200
assert get_email_address_by_address(TEST_EMAIL_ADDRESS)
assert b'*****@*****.**' in response.data
logout(client)
reset_response = request_reset_password(client, db, TEST_RESET_USER\
, TEST_EMAIL_ADDRESS)
# Assert redirected to update password page
assert b'token' in reset_response.data
# Assert token is generated
assert get_user_by_name(TEST_RESET_USER).get_reset_token()
def register():
# check if current user is already logged in
if current_user.is_authenticated:
return redirect(url_for('main.index'))
form = RegistrationForm()
# Action after received form data
if form.validate_on_submit():
user = User(user_name=form.username.data,
email=form.email.data,
about_me=form.about_me.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
token = user.generate_token('confirm')
send_email(user.email,
'Confirm Your Account',
'mail/confirm',
user=user,
token=token)
# Login automatically
login_user(user)
flash(alerts['login_success'])
return redirect(url_for('main.index'))
return render_template('auth/register.html', form=form, title='Register')
def get_roles():
data = {'status': True}
with User() as user:
data['roles'] = user.get_roles()
return jsonify(data)
def verify_pwd():
postData = request.get_json(force=True)
print(postData)
#这里说明第一次登陆，是没有token的
if postData['token'] == "":
g.user = User(postData['stuId'], postData['Pwd'])
#对账号密码进行验证
getClass = myJwxtInfo(g.user.get_stuid(), g.user.get_pwd())
token = g.user.generate_user_token()
if getClass.before_getCurriculum(getClass.jwxt_Login(postData['yzm']),
token):
print("即将成功返回jwxt登录token")
return jsonify({
'status': '100',
'token': token,
'stuId': g.user.get_stuid(),
'xnd': getClass.returnXnd()
})
else:
print("看样子有错误jwxt登录更新")
return jsonify({'status': '101', 'message': 'error'})
#有token，直接去Mongodb查找数据
else:
print('you token')
if verify_token(postData['stuId'], postData['token']):
pass
else:
return jsonify({'status': '101', 'message': 'error'})
def index():
if not github.authorized:
return redirect("/auth")
resp = github.get("/user")
assert resp.ok
githubData = resp.json()
u = User.where('github_id', githubData["id"]).first()
if u == None:
print("none")
user = User()
user.name = githubData["name"]
user.username = githubData["login"]
user.email = githubData["email"]
user.github_id = githubData["id"]
user.avatar_url = githubData["avatar_url"]
user.github_api_url = githubData["url"]
user.access_token = session["github_oauth_token"]["access_token"]
user.github_html_url = githubData["html_url"]
user.save()
u = user
session["user"] = u.to_json()
return render_template("search.html", user=u)
def post():
"""
Handles returning the view for register page, and redirects user to post view once registeration is completed
:return: jinjaTemplate
"""
error = None
if request.method == "POST":
email = request.form.get("email")
username = request.form.get("username")
password1 = request.form.get("password1")
password2 = request.form.get("password2")
existentUsername = User.query.filter_by(username=username).first()
existentEmail = User.query.filter_by(email=email).first()
if (password1 != password2):
error = "Passwords did not match!"
elif (existentUsername or existentEmail):
error = "Username or email already in use!"
else:
user = User(email=email, username=username, password=password1)
db.session.add(user)
db.session.commit()
session["logged_in"] = user.id
flash("You have successfully logged in!")
return redirect(url_for('list'))
return render_template("registration.html", error=error)
def setUp(self):
super().setUp()
user = User(username='******', email='*****@*****.**', password='******')
self.db.session.add(user)
self.db.session.commit()
self.userId = user.id
self.username = user.username
def test_user_verify_password_empty_string_argument(self):
try:
user = User("marcos", "*****@*****.**", "12345")
user.verify_password("")
self.fail("Exception was expected.")
except:
pass
def register():
firstname = request.form['firstName']
lastname = request.form['lastName']
email = request.form['email']
password = request.form['password']
users[email] = (User(firstname, lastname, email, password))
return redirect('/')
def register():
name = request.json['name']
cpf = request.json['cpf']
email = request.json['email']
phone = request.json['phone']
password = request.json['password']
type_user = request.json['type_user']
user = User(name, email, cpf, phone, password)
db.session.add(user)
db.session.commit()
resultUser = user_share_schema.dump(
User.query.filter_by(email=email).first())
if type_user == 1:
passenger = Passenger(resultUser['id'], )
db.session.add(passenger)
db.session.commit()
if type_user == 2:
car = request.json['car']
car_plate = request.json['car_plate']
cnh = request.json['cnh']
driver = Driver(resultUser['id'], car, car_plate, cnh)
db.session.add(driver)
db.session.commit()
return jsonify(resultUser)
def validate(self):
if not Form.validate(self):
return None
user = User.query.filter_by(username=self.username.data).first()
if user:
self.username.errors.append('This username is already in use')
return False
else:
if self.password.data != self.repeat_password.data:
self.repeat_password.errors.append('Passwords don\'t match')
return False
allowed = set(string.ascii_lowercase + string.ascii_uppercase +
string.digits + ' ')
if set(self.username.data) <= allowed:
if len(self.username.data) < 16:
new_user = User(self.username.data, self.password.data)
db.session.add(new_user)
db.session.commit()
return new_user
else:
self.username.errors.append(
'Username must be 15 characters or less')
return False
else:
self.username.errors.append(
'Username may only contain letters and digits')
return False
def login_check(self):
users = User()
form = request.form
username = form['username']
password = form['password']
try:
user = users.query.filter_by(username=username).first()
if not user:
raise Exception('maaf ada yang salah')
hash_data = bcrypt.check_password_hash(user.password, password)
if hash_data:
session['id'] = user.id
session['username'] = user.username
return session['username']
else:
raise Exception("maaf password atau username salah")
except Exception as e:
flash('maaf password anda salah', 'danger')
return redirect(url_for('route.login'))
def login_with_google():
global last_page
if not google.authorized:
return redirect(url_for("google.login"))
# get google user information
google_user = google.get("/plus/v1/people/me").json()
# log("what is in resp", google_user)
email = google_user["emails"][0]["value"]
username = google_user['displayName']
picture = google_user['image']['url']
picture_resized = picture.split("?sz=50")[0] + "?sz=" + "512"
role_id = Role.query.filter_by(name='user').first().id
confirmed = True
login_type = 'google'
user = User(email=email, username=username, confirmed=confirmed,
photo=picture_resized, login_type=login_type, role_id=role_id)
user_now = User.query.filter_by(username=username).first()
# add google user information to Database
if user_now is None:
db.session.add(user)
db.session.commit()
user1 = User.query.filter_by(username=username).first()
login_user(user1)
next = request.args.get('next')
if next is None or not next.startswith('/'):
next = last_page
return redirect(next)
def register():
logger.debug("Entering register function")
if current_user.is_authenticated:
logger.info("User is logged in, redirecting to dashboard")
return redirect(url_for('dashboard'))
form = RegistrationForm()
if request.method == 'POST':
logger.debug("Register form submitted")
if form.validate_on_submit():
user_exist = get_user_by_name(form.username.data)
if user_exist == None:
new_user = User(username=form.username.data)
new_user.set_password(form.password.data)
new_user.set_last_logged_in(datetime.now())
db.session.add(new_user)
db.session.commit()
login_user(new_user)
session["user_id"] = new_user.get_id()
session["username"] = new_user.get_username()
logger.debug("Successfully created user %s", new_user)
return redirect(url_for('dashboard'))
else:
flash("Username already taken!")
logger.error("Username already taken")
logger.warning("Registration failed, user not registered")
return redirect(url_for("register"))
return render_template('register.html', form=form)
def create_user(self, email, nickname, password):
new_user = User()
new_user.Email = email
new_user.Nickname = nickname
new_user.Password = password
new_user.save()
return new_user
def register():
data = request.get_json()
user = User()
user.email = data['email']
user.password = data['password']
db.session.add(user)
db.session.commit()
return jsonify(user.to_dict())
def test_user_role(self):
Role.insert_roles()
u = User(name='ose', password='******', email='*****@*****.**')
self.assertTrue(u.can(Permission.COMMENT))
self.assertTrue(u.can(Permission.WRITE))
self.assertTrue(u.can(Permission.FOLLOW))
self.assertFalse(u.can(Permission.ADMIN))
self.assertFalse(u.can(Permission.MODERATE))
def setUp(self):
super().setUp()
self.user = User(username='******',
email='*****@*****.**',
password='******')
self.db.session.add(self.user)
self.db.session.commit()
def setUp(self):
super().setUp()
self.session.begin_nested()
self.user = User(name='Test User', email='*****@*****.**')
self.session.add(self.user)
self.session.commit()
def __init__(self):
"""
Initialise class with configuration
"""
self.user = User()
return None
def format_user(dict_json):
u = User()
u.name = dict_json.get("name", "")
u.password = dict_json.get("password", "")
u.username = dict_json.get("username", "")
u.email = dict_json.get("email", "")
u.role = dict_json.get("role", "1")
return u
def logout():
form = SignupForm()
if form.validate_on_submit():
user = User()
form.populate_obj(user)
user.ID = User.objects.count() + 1
user.save()
return redirect('/login')
return render_template('accounts/signup.html', form=form)
def is_data_exist(self, args):
users = User()
user = users.query.filter_by(username=args).first()
if (user):
return True
else:
return False
def add_user(role, name, password=None, user_group_id=1):
if not password:
password = name
user = User(username=name, real_name=name, password=password, role=role, group_id=user_group_id)
db.session.add(user)
db.session.flush()
UserGroup.query.filter(UserGroup.id == user.group_id).update({'leader_id': user.id, 'leader_name': user.name},
synchronize_session=False)
db.session.commit()
def create_admin():
"""Creates the admin user."""
print "creating admin user..."
db.session.add(
User(name='Administrator',
email='*****@*****.**',
password='******',
level=0))
db.session.commit()
