def setUp(self):
super().setUp()
user1 = User (
oauth_id="password",
name="test",
username="******",
email="*****@*****.**"
)
user2 = User (
oauth_id="google",
name="test",
email="*****@*****.**"
)
with self.app.app_context():
db.session.add(user1)
db.session.add(user2)
db.session.commit()
self.success_test_params_user = [
{
KEY_INPUT: {KEY_USER: "******"},
KEY_EXPECTED: {
KEY_SUCCESS: False,
KEY_MESSAGE: "Username already exist. please try another one."
}
},
{
KEY_INPUT: {KEY_USER: "******"},
KEY_EXPECTED: {
KEY_SUCCESS: True,
KEY_USER_ID: 1
}
}]
self.success_test_params_error = {"error": "Malformed request"}
def setUp(self):
super().setUp()
self.user_id = 1
self.registration_time = datetime.datetime.utcnow()
user = User(
id=self.user_id,
name="Current user",
email="*****@*****.**",
registration_datetime=self.registration_time,
is_public=False,
)
self.other_user_id = 2
other_user = User(
id=self.other_user_id,
name="Other user",
email="*****@*****.**",
registration_datetime=self.registration_time,
is_public=True,
)
self.private_user_id = 3
private_user = User(
id=self.private_user_id,
name="Private user",
email="*****@*****.**",
registration_datetime=self.registration_time,
is_public=False,
)
with self.app.app_context():
db.session.add(user)
db.session.add(other_user)
db.session.add(private_user)
db.session.commit()
def seed_db():
"""Seeds the database."""
from server.tests.utils import JOHN, JOHN_EMAIL, JOHN_PASSWORD
from server.tests.utils import JANE, JANE_EMAIL, JANE_PASSWORD
db.session.add(
User(username=JOHN, email=JOHN_EMAIL, password=JOHN_PASSWORD))
db.session.add(
User(username=JANE, email=JANE_EMAIL, password=JANE_PASSWORD))
db.session.commit()
def register():
# Check if user is logged in
if current_user.is_authenticated:
return redirect(url_for('main.home'))
# Initialize form object
form = RegistrationForm()
# Validate form POST
if form.validate_on_submit():
# Hash user password
hashed_pw = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
# Create new user
user = User(username=form.username.data,
email=form.email.data,
password=hashed_pw)
db.session.add(user)
db.session.commit()
# User feedback message
flash('Your account has been created! You are able to log in',
'success')
return redirect(url_for('users.login'))
return render_template('register.html', title='Register', form=form)
def test_Feeder_User(self):
user1 = User(username="******")
user2 = User(username="******")
feeder = Feeder()
feeder.users.append(user1)
user2.feeders.append(feeder)
db.session.add(feeder)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
self.assertTrue(len(feeder.users.all()) == 2)
self.assertEqual(user1.feeders[0], feeder)
def oauth_callback(social_network_name):
oauth_dict = oauth_apps[social_network_name]
oauth_app = oauth_dict['oauth']
resp = oauth_app.authorized_response()
if resp is None or isinstance(resp, OAuthException):
return None
user_data = oauth_app.get(oauth_dict['fetch_query'],
token=(resp['access_token'], '')).data
user = User.query.filter(((User.social_id == user_data['id'])
& (User.social_type == social_network_name))
| (User.email == user_data['email'])).first()
if user is None:
user_fields = oauth_dict['custom_fields']
user = User(first_name=user_data[user_fields['first_name']],
last_name=user_data[user_fields['last_name']],
gender=user_data.get('gender', None),
social_id=user_data['id'],
email=user_data['email'],
role='user',
social_type=social_network_name)
db.session.add(user)
db.session.commit()
if user.is_active():
login_user(user)
else:
return render_template('auth/banned.html')
return redirect(url_for('static', filename='auth_close.html'))
def test_delete_user(test_client, init_database):
test_user = User(name="dwain_johnson")
db.session.add(test_user)
db.session.commit()
db.session.delete(User.query.filter_by(name="dwain_johnson").first())
db.session.commit()
assert (len(User.query.filter_by(name="dwain_johnson").all()) == 0)
def create_user(kwargs):
password = kwargs.pop('password')
accid = kwargs.get("accid")
name = kwargs.get("name")
info = request_im(accid, name) # {'token': , 'name': , 'accid': }
user = User(**info)
user.set_password(password)
def register():
data = request.json
try:
username = data.get("username")
email = data.get("email")
phonenumber = data.get("phonenumber")
try:
existUsername = User.query.filter_by(username=username).first()
if existUsername:
return jsonify(
success=False,
error="This username is alrealy exist"
)
existEmail = User.query.filter_by(email=email).first()
if existEmail:
return jsonify(
success=False,
error="This email is alrealy exist"
)
existPhonenumber = User.query.filter_by(username=username).first()
if existPhonenumber:
return jsonify(
success=False,
error="This phonenumber is alrealy exist"
)
except:
pass
address = data.get("address")
password = data.get("password")
confirm_password = data.get("confirm_password")
if password != confirm_password:
return jsonify(
success=False,
error="password not match"
)
newUser = User(username, email, phonenumber, address, password)
try:
db.session.add(newUser)
db.session.commit()
return jsonify(
success=True,
)
except:
return jsonify(
success=False,
error="cannot register"
)
except:
return jsonify(
success=False,
error="cannot register"
)
def test_multiple_user(client, app):
fake = Faker()
for _ in range(2):
u = User(email=fake.company_email(),
password=fake.password(),
username=fake.name(),
activated=True)
u.save()
for _ in range(randrange(1, 10)):
p = Program(name=fake.name(), code=fake.text(), language="python")
u.programs.append(p)
u.save()
for user in User.objects:
with app.app_context():
token = user.create_token()
res = client.get('/api/users/1.0/programs',
headers={'Authorization': 'Bearer {}'.format(token)})
assert res.status_code == 200
assert len(user.programs) == len(res.json)
user1 = User.objects[0]
user2 = User.objects[1]
with app.app_context():
token = user1.create_token()
res = client.get('/api/users/1.0/programs/{}'.format(user2.programs[0].id),
headers={'Authorization': 'Bearer {}'.format(token)})
assert res.status_code == 404
def test_update_task(test_client, init_database):
s = db.session
# create users
users = []
for i in range(1, 5):
users.append(User(name="user_{}".format(i)))
s.bulk_save_objects(users)
user_ids = [id for (id, ) in s.query(User.id).all()]
assert (len(user_ids) == 4)
task = Task.query.first()
assert task is not None
request_content = {
'name': "test_task_updated",
'status': 2,
'users': user_ids,
}
response = test_client.patch('/api/tasks/' + str(task.id),
data=json.dumps(request_content),
content_type='application/json')
assert response.status_code == 200
updated_task = s.query(Task).filter_by(id=task.id).first()
assert updated_task is not None
assert updated_task.name == request_content['name']
assert updated_task.status == request_content['status']
assert len(updated_task.users) == 4
def make_student(self, n, section=None):
user = User(email='student{0}@aol.com'.format(n))
participant = Enrollment(user=user,
course=self.course,
section=section)
db.session.add(participant)
return user
def main(argv=sys.argv):
if len(argv) != 2:
usage(argv)
config_uri = argv[1]
setup_logging(config_uri)
settings = get_appsettings(config_uri)
engine = engine_from_config(settings, 'sqlalchemy.')
DBSession.configure(bind=engine)
Base.metadata.create_all(engine)
with transaction.manager:
# Create default models
group = Group(name="group:admin")
DBSession.add(group)
user = User(name='Test', password=hash_password('1234'))
DBSession.add(user)
new_group_id = int(
DBSession.query(Group).filter(Group.name == group.name).first().id)
new_user_id = int(
DBSession.query(User).filter(User.name == user.name).first().id)
user_in_group = UserInGroup(user_id=new_user_id, group_id=new_group_id)
DBSession.add(user_in_group)
def generate_auth_token(server_token,
username,
name=None,
email=None,
duration_days=1):
# Check for a valid server token in the database
server = Server.query.filter_by(server_token=server_token).first()
if not server:
raise InvalidServerToken({"message": "Invalid server token"})
# Get user from db or create a new one
user_id = '{}/{}'.format(server.server_id, username)
user = User.query.filter_by(user_id=user_id).first()
if not user:
user = User(user_id=user_id, user_name=name, user_email=email)
db.session.add(user)
# Attach the new user to the server
server.users.append(user)
auth_token = base64.urlsafe_b64encode(os.urandom(12))
current_date = dt.datetime.today()
expiry_date = current_date + dt.timedelta(duration_days)
access = Access(auth_token=auth_token,
creation_date=current_date,
expiration_date=expiry_date)
db.session.add(access)
# Attach the new token to the user
user.access.append(access)
db.session.commit()
return auth_token, expiry_date
def register():
json_data = request.json
code = 403
user = False
status_text = ''
try:
user = User(email=json_data['email'].lower(),
password=json_data['password'])
except Exception as e:
status_text = str(e)
if user:
try:
db.session.add(user)
# temporary feature flag
if app.config['ENABLE_AUTO_SHARE_RULES']:
for rule in db.session.query(Rule).filter_by(
source='gobo', shareable=True).all():
user_rule = UserRule(user.id, rule.id)
db.session.add(user_rule)
db.session.commit()
status_text = 'success'
code = 200
login_user(user, remember=True)
except IntegrityError:
status_text = 'A user with that e-mail already exist!'
except Exception as e:
status_text = "Something went wrong. Reload the page and try again."
logger.exception(e)
finally:
db.session.close()
return jsonify({'statusText': status_text}), code
def signup():
logger.debug('begin user registration')
logger.debug('validating request body')
body = request.json
errors.ValidationError.raise_assert(body is not None, 'json missing')
if 'username' not in body or 'password' not in body:
raise errors.APIError('username and password required')
username = body['username'].lower().strip()
logger.debug('searching for existing user "{}"'.format(username))
query = db.session.query(User).filter(
db.func.lower(User.username) == username)
user = query.first()
errors.AuthError.raise_assert(user is None, 'user already exists')
logger.debug('creating new user')
user = User(username=username,
display_name=(body.get('display_name') or username))
logger.debug('setting password')
user.set_password(body['password'])
logger.debug('writing to db')
db.session.add(user)
db.session.commit()
return jsonify({'code': 'success'})
def register():
username = request.json.get('username')
password = request.json.get('password')
mail = request.json.get('email')
user = User.query.filter_by(username=username).first()
email = User.query.filter_by(email=mail).first()
if user:
return jsonify(
result={
'message': 'Konto o podanej nazwie użytkownika już istnieje.',
'category': 'danger'
})
if email:
return jsonify(
result={
'message': 'Konto o podanym adresie email już istnieje!',
'category': 'danger'
})
hashed_password = bcrypt.generate_password_hash(password).decode('utf-8')
newUser = User(username=username,
password=hashed_password,
email=mail,
registered_on=datetime.now())
token = generate_confirmation_token(newUser.email)
confirm_url = url_for('auth.confirm_email', token=token, _external=True)
subject = "Potwierdź swoje konto"
send_email(newUser.email, subject, confirm_url)
db.session.add(newUser)
db.session.commit()
return jsonify(
result={
'message':
'Rejestracja przebiegła pomyślnie, na podany adres email została wysłana wiadomość z linkiem wymaganym do dokończenia rejestracji.',
'category': 'succes'
})
def test_add_user_duplicate_username(self):
add_user()
duplicate_user = User(username=NAME,
email='*****@*****.**',
password=PASSWORD)
db.session.add(duplicate_user)
self.assertRaises(IntegrityError, db.session.commit)
def setup_default():
admin = User(email="*****@*****.**", is_admin=True)
db.session.add(admin)
admin = User(email="*****@*****.**", is_admin=True)
db.session.add(admin)
db.session.commit()
course = Course(offering='cal/cs61a/sp16',
institution='UC Berkeley',
display_name='CS 61A',
active=True)
db.session.add(course)
url = 'https://github.com/Cal-CS-61A-Staff/ok-client/releases/download/v1.5.5/ok'
ok = Version(name='ok-client', current_version='v1.5.4', download_link=url)
db.session.add(ok)
db.session.commit()
def test_add_user_duplicate_email(self):
add_user()
duplicate_user = User(username='******',
email=EMAIL,
password=PASSWORD)
db.session.add(duplicate_user)
self.assertRaises(IntegrityError, db.session.commit)
def post(self):
# get the post data
post_data = request.get_json()
# check if user already exists
user = User.query.filter_by(email=post_data.get('email')).first()
if not user:
try:
user = User(email=post_data.get('email'),
password=post_data.get('password'))
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = user.encode_auth_token(user.id)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode()
}
return make_response(jsonify(responseObject)), 201
except Exception as e:
responseObject = {
'status': 'fail',
'message': 'Some error occurred. Please try again.'
}
return make_response(jsonify(responseObject)), 401
else:
responseObject = {
'status': 'fail',
'message': 'User already exists. Please Log in.',
}
return make_response(jsonify(responseObject)), 202
def test_user_password(self, client):
""" Test password hashing and checking """
admin = User('admin', 'pass')
assert admin.username == 'admin'
assert admin.verify_password('pass')
def login():
if not request.json or not 'username' in request.json or not 'password' in request.json:
return jsonify({"error": "Invalid request format"}), 404
else:
if session.get('logged_in'):
return jsonify(success=True), 200
else:
try:
# Strip the unicode
username = str(request.json['username'])
client = myfitnesspal.Client(username,
request.json['password'])
clients[username] = client
session['logged_in'] = True
session['username'] = username
print('Querying...')
if User.query.filter_by(username=username).first():
print("Successful login.")
return jsonify(success=True), 200
else:
newUser = User(username, request.json['password'])
db.session.add(newUser)
db.session.commit()
print("User created.")
return jsonify(success=True), 200
except ValueError:
raise InvalidUsage('Invalid Credentials', status_code=401)
def create(self, validated_data):
password = validated_data.pop('password')
user = User(**validated_data)
user.username = validated_data.get('email')
user.set_password(password)
user.save()
return user
def new_user():
u = User(
username="******",
email="*****@*****.**")
u.set_password("Password1234567890!")
return u
def register():
# get the post data
post_data = request.get_json()
# check if user already exists
user = User.query.filter_by(email=post_data.get('email')).first()
if not user:
user = User(
email=post_data.get('email'),
password=post_data.get('password')
)
# insert the user
db.session.add(user)
db.session.commit()
# generate the auth token
auth_token = encode_auth_token(user.id, user.admin)
responseObject = {
'status': 'success',
'message': 'Successfully registered.',
'auth_token': auth_token.decode(),
'token_max_age': app.config.get('JWT_MAX_AGE')
}
return make_response(jsonify(responseObject)), \
html_codes.HTTP_OK_CREATED
else:
raise InvalidAPIUsage(
message='User already exists. Please Log in.',
status_code=html_codes.HTTP_BAD_FORBIDDEN
)
def test_Feederusage(self):
user1 = User(username="******")
feeder = Feeder()
#feeder.users.append(user1)
moment1 = FeedMoment(amount=2, Feeder=feeder)
moment1.setFeedTime(5, 12)
moment2 = FeedMoment(amount=3, Feeder=feeder)
moment2.setFeedTime(14, 15)
db.session.add(feeder)
db.session.add(moment1)
db.session.add(moment2)
db.session.commit()
#print(feeder.get_lastupdate())
self.assertEqual(moment2.last_updated,
feeder.get_lastupdate()) #test global last update
#!! current time is important!
time = datetime.now().hour * 60 + datetime.now().minute
print(time)
if time > moment2.feed_time:
self.assertEqual(feeder.get_next_moment(), moment1)
else:
self.assertEqual(feeder.get_next_moment(), moment2)
def add_user(username, birthdate):
if get_user(username):
return None
user = User(username=username, birthdate=birthdate)
db.session.add(user)
db.session.commit()
return user
def create(self, email: str, profile: Profile) -> User:
user = User(fake.user_name(), email, profile)
self.users.append(user)
return self.get(user.id)
def post(self, request):
bodyUnicode = request.body.decode('utf-8')
jsonRequestData = json.loads(bodyUnicode)
username = jsonRequestData["username"]
password = jsonRequestData["password"]
name = jsonRequestData["name"]
user = User()
user.setUsername(username)
user.setPassword(password)
user.setName(name)
try:
# Save may raise an exception (for example if the username is already in use)
user.save()
except Exception as ex:
return JsonResponse({
'status': "error",
"message": "O username escolhido já existe."
})
return JsonResponse({
'status': "success",
"message": "Registo efetuado com sucesso.",
"username": user.getUsername(),
"name": user.getName(),
"userId": user.getId()
})
