def test_roles(self):
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
r1 = Role(name='Admin')
r2 = Role(name='Operator')
r3 = Role(name='Client')
self.db.session.add(u1)
self.db.session.add(u2)
self.db.session.add(r1)
self.db.session.add(r2)
self.db.session.add(r3)
self.db.session.commit()
u1 = User.find_by_username('john')
u2 = User.find_by_username('susan')
self.assertEqual(u1.roles.all(), [])
self.assertEqual(u2.roles.all(), [])
u1.add_role(r1)
u2.add_role(r2)
u2.add_role(r3)
self.db.session.add(u1)
self.db.session.add(u2)
self.db.session.commit()
# John has exactly 1 role?
self.assertEqual(u1.roles.count(), 1)
# John has the 'Admin' role?
self.assertEqual(u1.roles.first().name, 'Admin')
# Susan has exactly 2 roles?
self.assertEqual(u2.roles.count(), 2)
# Susan has the role 'Client'?
self.assertTrue(u2.has_role(r3))
def yelp_business_match():
if 'Authorization' not in request.headers:
abort(401)
if not User().verify_key(request.headers.get('Authorization')):
abort(401)
if not request.is_json:
abort(400)
request_data = request.get_json(silent=True)
if request_data is None:
abort(400)
if 'name' not in request_data or 'street_address' not in request_data or 'city' not in request_data \
or 'state' not in request_data or 'country' not in request_data:
return make_response(jsonify({'error': 'Missing required attributes'}),
400)
user_id = User().get_user_id(request.headers.get('Authorization'))
YelpData().yelp_request(yelp_request=request_data, user_id=user_id)
data = YelpData().get_business_match_data(
user_id=user_id,
name=request_data['name'],
address1=request_data['street_address'],
city=request_data['city'],
state=request_data['state'],
country=request_data['country'])
return jsonify(data)
def general_user(session):
try:
general_user = User.query.filter_by(
google_id="*****@*****.**").first()
assert not general_user
general_user = User(google_id="*****@*****.**",
en_name="Hammington",
ko_name="Hee San",
entry_date=datetime.datetime(2017, 1, 1),
admin=False)
session.add(general_user)
except BaseException:
general_user = User(google_id="*****@*****.**",
en_name="Hammington",
ko_name="Hee San",
entry_date=datetime.datetime(2017, 1, 1),
admin=False)
general_user.google_id = str(random.randint(
1, 1000)) + "_" + general_user.google_id
session.add(general_user)
session.commit()
return general_user
def setUp(self):
self.app = create_app('testing')
self.test_app = self.app.test_client()
with self.app.app_context():
db.create_all()
user = User(first_name="Jimmy",
last_name="Cocopuff",
email="*****@*****.**",
password="******")
with self.app.app_context():
db.session.add(user)
db.session.commit()
user = User(first_name="Jimmy",
last_name="Cocobeans",
email="*****@*****.**",
password="******")
with self.app.app_context():
db.session.add(user)
db.session.commit()
item = Item(
user_id=1,
title="Tea Set",
description="Antique Tea set",
price=140.00,
category="furniture",
charity="Big Cat Rescue",
charity_url="http://www.thisisatotallyligiturl.com",
charity_score=4,
charity_score_image=
"https://d20umu42aunjpx.cloudfront.net/_gfx_/icons/stars/4stars.png",
image="img.ul",
auction_length=5)
with self.app.app_context():
db.session.add(item)
db.session.commit()
item = Item(
user_id=1,
title="Rocking Chair",
description="Vintage wood rocking chair",
price=40.00,
category='furniture',
charity='Big Cat Rescue',
charity_url="http://www.thisisatotallyligiturl.com",
charity_score=4,
charity_score_image=
"https://d20umu42aunjpx.cloudfront.net/_gfx_/icons/stars/4stars.png",
image='img.ul',
auction_length=5)
with self.app.app_context():
db.session.add(item)
db.session.commit()
def test_users_inserts(self):
u1 = User(email='*****@*****.**')
u1.set_password('123')
u2 = User(email='*****@*****.**')
u2.set_password('123')
u3 = User(email='*****@*****.**')
u3.set_password('123')
self.db.session.add(u1)
self.db.session.add(u2)
self.db.session.commit()
self.db.session.add(u3)
self.assertRaises(IntegrityError, self.db.session.commit)
self.db.session.rollback()
def test_get_user_by_id(self):
user1 = User(user_name="Princess.Kopf", email="*****@*****.**")
user2 = User(user_name="ABD", email="*****@*****.**")
with self.app.app_context():
db.session.add(user1)
db.session.add(user2)
db.session.commit()
response = self.test_app.get('/api/users/1', follow_redirects=True)
# Assert response is 200 OK.
self.assertEquals(response.status, "200 OK")
payload = json.loads(response.data)
self.assertEquals(payload['user_name'], "Princess.Kopf")
self.assertEquals(payload['email'], "*****@*****.**")
def another_admin(session):
user = User(google_id="*****@*****.**", en_name="test_name", admin=True)
session.add(user)
session.commit()
assert User.query.get(user.id).admin == True
return user
def user_is_general(session):
user = User(google_id="*****@*****.**", en_name="name", admin=False)
session.add(user)
session.commit()
assert user.admin == False
return user
def test_client_with_db():
flask_app = create_app('config.Test')
# Create a test client using the Flask application configured for testing
with flask_app.test_client() as testing_client:
# Establish an application context
with flask_app.app_context():
db.create_all()
# Insert user data
user = User('*****@*****.**', generate_password_hash('password'))
db.session.add(user)
# Insert insurance data
insurances = [
Insurance('Private Health Insurance', 300.00),
Insurance('Household Contents Insurance', 10.00),
Insurance('Public Health Insurance', 200.00),
Insurance('Expat Health Insurance', 85.00),
Insurance('Legal Insurance', 25.00),
Insurance('Life Insurance', 20.00)
]
db.session.bulk_save_objects(insurances)
# Commit the changes for the users
db.session.commit()
yield testing_client
db.drop_all()
def post(self):
data = request.get_json()
user = User(username=data['username'])
user.set_password(data['password'])
db.session.add(user)
db.session.commit()
return "User " + user.username + " has been saved", 201
def github_auth():
"""
Github OAuth, redirects to github OAuth and obtains token using client id and secret
:return:
"""
if 'code' in request.args:
github_url = 'https://github.com/login/oauth/access_token'
data = {'client_id': client_id,
'client_secret': client_secret,
'code': request.args.get('code'),
}
headers = {'Accept': 'application/json'}
r = requests.post(github_url, data=data, headers=headers)
results = r.json()
print(results)
# Note: Once values are added to session, Flask will turn these into
# a cookie that will be stored on the client side
# (using set-cookie on header since cookies is not a valid header on
# a response?)
# Because of the secret key, values are stored with cryptography
session['username'] = get_username(results.get('access_token'))
session['code'] = request.args.get('code')
# Import the user model and create a new instance of the object
users = database.all('User')
for user in users.values():
if user.user_name == session['username']:
session['id'] = user.id
return redirect(url_for('user.homepage'))
new_user = User(**({'user_name': session.get('username'), 'level_id': '100'}))
new_user.save()
session['id'] = new_user.id
return redirect(url_for('user.homepage'))
def post(self):
current_user = get_jwt_identity()
if current_user['role'] != 'system_admin':
return {
'status': STATUS_CODE['AUTH'],
'message': 'Permission denied'
}
args = user.parse_args()
isExists = User.objects(email=args['email']).first()
if isExists:
return {
'status': STATUS_CODE['ERROR'],
'message': 'Email already exists'
}
isExistsAccountNumber = User.objects(
account_number=args['account_number']).first()
if isExistsAccountNumber:
return {
'status': STATUS_CODE['ERROR'],
'message': 'Account number already exists'
}
User(account_number=args['account_number'],
balance=args['balance'],
firstname=args['firstname'],
lastname=args['lastname'],
age=args['age'],
gender=args['gender'],
address=args['address'],
employer=args['employer'],
email=args['email'],
city=args['city'],
state=args['state']).save()
return {'status': STATUS_CODE['SUCCESS'], 'message': 'Successfully'}
def user_data_to_ucenter():
db.engine.execute("ALTER TABLE %s RENAME TO %s " %
(User.__tablename__, Userold.__tablename__))
db.create_all()
user_olds = Userold.query.all()
for user_old in user_olds:
user = User()
user.id = user_old.id
user._active = user_old._active
user.username = user_old.username
user.email = user_old.email
user.title = user_old.title
user.avatar = user_old.avatar
user.created_on = user_old.created_on
user.updated_on = user_old.updated_on
user.created_by = user_old.created_by
user.updated_by = user_old.updated_by
db.session.add(user)
store_id = user_old.store_id
store_name = user_old.storename
roles = user_old.roles
type = user_old.type
user.update_permission_auth(store_id, store_name, type, roles)
db.session.commit()
def set_default():
record = User().query_record(id=1)
if record: return {'code': 400, 'message': 'db has initialized'}, 400
default_role = {
'name': 'admin',
'alias': '管理员',
'status': 1,
}
role = Role.create_record(**default_role)
default_user = {
'name': 'David',
'pwd': '123456',
'status': 1,
'role_id': 1
}
user = User.create_record(**default_user)
return {
'user': user.to_dict(rules=('-pwd', '-role')),
'role': role.to_dict(rules=('-users', )),
}, 201
def sign_up():
data = request.args
email = data['email']
password = data['password']
user = User.find_user_by_email(email)
if not user:
try:
user = User(email=email, password=password, username=email)
db.session.add(user)
db.session.commit()
identity = {'email': user.email, 'name': user.username}
access_token = create_access_token(identity=identity)
response_object = {
'status': 'success',
'message': 'Successfully signed up',
'auth_token': access_token
}
return make_response(jsonify(response_object)), 201
except Exception as e:
response_object = {
'status': 'fail',
'message': 'Could not create account',
'error': ','.join(e.args)
}
return make_response(jsonify(response_object)), 500
else:
response_object = {'status': 'fail', 'message': 'User already exists'}
return make_response(jsonify(response_object)), 400
def signup():
'''
Display the sign up form on GET and sign up on POST
'''
if request.method == 'POST':
email = request.form.get('email')
password = request.form.get('password')
name = request.form.get('name')
# Check that all fields are not null
if not email or not password or not name:
flash('Please fill in all fields.')
return render_template('signup.html')
# Check if the user already exists
user = User.query.filter_by(email=email).first()
if user:
flash('User already exists.')
return render_template('signup.html')
# Create the user
new_user = User(email=email, name=name)
new_user.set_password(password)
new_user.create_new_user()
# Visit the login page
return redirect(url_for('authentication.login'))
# Render the sign up page
else:
return render_template('signup.html')
def signup(data: dict) -> typing.NoReturn:
user_id = data.get('user_id')
name = data.get('name')
password = data.get('password')
if not name or not name or not password:
raise SignupException('空欄があります')
user = User.query.filter_by(user_id=user_id).first()
if user:
raise SignupException('このIDは既に使われています')
if not user_id.isalnum():
raise SignupException('ユーザ名は英数字のみにして下さい')
required_password_length = 1
if len(password) < required_password_length:
raise SignupException(
f'パスワードは {required_password_length} 文字以上にして下さい')
new_user = User(user_id, name, password)
try:
db.session.add(new_user)
db.session.commit()
except Exception:
db.session.rollback()
raise SQLAlchemyError
finally:
db.session.close()
def register():
form = RegistrationForm(request.form, meta={'locales': ['fa']})
if request.method == 'POST' and form.validate():
plain_email = re.match(re.compile("(.*)(@.*)"), form.email.data)
user_email = plain_email.group(1).replace('.',
'') + plain_email.group(2)
new_user = User(email=user_email, password=form.password.data)
db.session.add(new_user)
token = new_user.generate_confirmation_token()
url = url_for('user.confirm', token=token, _external=True)
try:
email.send(
new_user.email, 'Confirm Your Account',
render_template('user/email/confirm.html',
user=new_user,
url=url))
db.session.commit()
new_user.add_ability(Abilities.TYPICAL)
except ConnectionError:
flash(
u'.ارسال ایمیل تایید حساب کاربری با مشکل روبه رو شد.مجددا تلاش کنید'
)
db.session.rollback()
return render_template('user/register.html', form=form)
flash(u'.یک ایمیل تایید حساب کاربری برای شما ارسال شده است')
return redirect(url_for('main.index'))
return render_template('user/register.html', form=form)
def post(self):
try:
data = parser.parse_args()
if User.find_by_username(data['email']):
raise InvalidInput(
"User {} already exists".format(data['email']))
new_user = User(
email=data['email'],
first_name=data['first_name'],
last_name=data['last_name'],
password=User.generate_hash(data['password']),
verified=False
)
new_user.save_to_db()
send_mail_to_verify(new_user)
return success(
{'message': 'User {} was created'.format(data['email']),
'success': True})
except SQLAlchemyError as e:
db.session.rollback()
return error({"success": False, 'message': str(e)})
except InvalidInput as e:
return error({"success": False, "message": str(e)})
def get_user(email):
cursor = DBHelper.mysql.get_db().cursor()
sql = 'select * from user where email=%s'
cursor.execute(sql, email)
user = cursor.fetchone()
if user:
return User(user)
return None
def test_password_recovery(self):
u1 = User(username='******', email='*****@*****.**')
db.session.add(u1)
db.session.commit()
token = u1.get_reset_password_token()
verified_user = User.verify_reset_password_token(token)
self.assertEqual(u1, verified_user)
def bmw_save_user(bmw_user_json):
result = bmw_user_json['content']
user = User.find(result['id'])
if user is None:
user = User()
user.from_auth(result)
user.save()
return user
def create_user(data):
user_data = data['user']
user = User(username=user_data['username'])
db.session.add(user)
for p in data['store_user_role_scopes']:
user.update_permission(p)
db.session.commit()
def post(self):
args = user_post_parser.parse_args()
user = User(**args)
db.session.add(user)
db.session.commit()
return user
def get_user_by_name(username):
cursor = DBHelper.mysql.get_db().cursor()
sql = 'select * from user where username=%s'
cursor.execute(sql, username)
user = cursor.fetchone()
if user:
return User(user)
return None
def auth_create():
form = CreateUserForm(request.form)
if not form.validate():
return render_template("auth/newform.html", form = form)
user = User(form.username.data, form.password.data)
db.session().add(user)
db.session().commit()
login_user(user)
return redirect(url_for("index"))
def test_add_note(self):
u1 = User(username='******', email='*****@*****.**')
db.session.add(u1)
db.session.commit()
self.assertEqual(u1.notes.count(), 0)
u1.add_note('test title', 'test description')
self.assertEqual(u1.notes.count(), 1)
self.assertEqual(u1.notes.filter_by(id=1).first().title, 'test title')
def configure_manger_accounts(app):
# [todo] configure super admin
plugins = Plugin.objects()
for plugin in plugins:
user = User.objects(card_id=plugin.identifier).first()
if user is None:
user = User(card_id=plugin.identifier,
name=plugin.identifier,
activated=True,
robot=True)
user.save()
user = User.objects(card_id='00000001').first()
if user is None:
user = User(card_id='00000001',
name='匿名用户',
activated=True,
robot=True)
user.save()
def sign_up():
user = User(**sign_up_user_params())
print(user.name)
if user.save():
access_token = create_access_token(identity=user.id)
refresh_token = create_refresh_token(identity=user.id)
return jsonify(access_token=access_token, refresh_token=refresh_token)
else:
return jsonify({"status": "usuário inválido"}), 404
def query_user (uid):
try:
record = User().query_record(uid)
return jsonify(record.to_dict())
except:
return 'query failed', 404
