async def drop_all(request, data):
data = self.request.get('data', {})
models = {
'user': request.app['models']['user'],
'chat': request.app['models']['message'],
'unread': request.app['models']['unread'],
'event': request.app['models']['event'],
'company': request.app['models']['company'],
'photo': request.app['models']['photo'],
}
[await i.clear_db() for i in models.values()]
leo = User(request.app.db, {
'login': '******',
'email': '*****@*****.**',
'password': '******'
})
lana = User(request.app.db, {
'login': '******',
'email': '*****@*****.**',
'password': '******'
})
artem = User(request.app.db, {
'login': '******',
'email': '*****@*****.**',
'password': '******'
})
await leo.create_user()
await lana.create_user()
await artem.create_user()
def setUp(self):
self.admin_u = User(email='test')
self.admin_u.roles.append(roles.TRAFFIC_LOG_ADMIN)
self.dj_u = User(email='test2')
self.dj_u.roles.append(roles.DJ)
self.user_u = User(email='test3')
def test_collisions(self):
us = User(email=self.user['email'])
us.put()
# This might actually happen because some filtering caused
# bad data in production.
another = User(email=self.user['email']) # same email
another.put()
self.sync()
def register():
"""
handle registration
"""
username = request.form.get('username', '')
password = generate_password_hash(request.form.get('password', ''))
user = User.query.filter_by(username=username).first()
if user:
return json.dumps([{
'success':
0,
"code":
1,
"message":
"Username {} unavailable".format(username)
}])
try:
user = User(username=username,
password=password,
user_since=datetime.datetime.now())
db.session.add(user)
db.session.commit()
login_user(user)
except:
# return json.dumps([{'success':0, "code" : 1, "message":"Database error"}])
error = "registration was not successful, please try again later or contact our team"
return redirect(url_for('main', error=error))
return redirect('/newuser')
def mongo_setup(app: Application):
app.client = ma.AsyncIOMotorClient(MONGO_HOST)
app.db = app.client[MONGO_DB_NAME]
app['models'] = {'users': User(app.db)}
app.on_startup.append(_check_users)
def setUp(self):
# assert self.client.login(email="*****@*****.**")
self.activeUser = User(email='*****@*****.**',
first_name='Active',
last_name='User',
is_active=True,
password='******')
_reindex(self.activeUser)
self.activeUser.save()
self.inactiveUser = User(email='*****@*****.**',
first_name='Inactive',
last_name='User',
is_active=False,
password='******')
_reindex(self.inactiveUser)
self.inactiveUser.save()
def create_admin():
"""Create user with admin rights"""
username = input("Enter username: "******"Invalid username!"
email = input("Enter email: ")
if not re.search(EMAIL_REGEX, email):
return "Invalid email!"
for _ in range(3):
password = getpass("Enter password: "******"Enter password again: ")
if password == password2:
break
print("Passwords are different!")
else:
return "Too many attempts. Try again"
try:
admin = User(username=username,
email=email,
password=password,
is_admin=True)
db.session.add(admin)
db.session.commit()
except IntegrityError:
db.session.rollback()
return "User with this username or email already exists"
return "Created successfully"
def test_create(self):
# We shouldn't emit the signal when we initially create a user
with test_utils.mock_handler(signals.user_profile_changed) as handler:
u = User()
u.first_name = 'ben'
u.save()
assert_false(handler.called)
def setUp(self):
self.user = User(username="******",
first_name="first",
last_name="last",
email="*****@*****.**")
self.user.set_password("test")
self.user.save()
def _create_user(self, data, email):
username = self._find_available_username(data)
first_name = data.get('first_name')
last_name = data.get('last_name')
facebook_uid = data.get('uid')
img_url = data.get('pic_square')
if email is None:
email = FacebookAuthBackend._generate_email(first_name)
user = User(username=username,
email=email,
first_name=first_name,
last_name=last_name)
temp_password = User.objects.make_random_password(length=24)
user.set_password(temp_password)
user.save()
if img_url:
img = ContentFile(requests.get(img_url).content)
name = img_url.split('/')[-1]
user.picture.save(name, img, False)
FacebookAccount.objects.create(uid=facebook_uid,
user=user,
avatar=img_url)
return user
def test_landing_page_shows_spots(self):
user = User(email='test')
user.save()
spot = models.Spot(title='Legal ID', type='Station ID')
spot_key = spot.put()
# assign it to every day of the week at the top of the hour:
constraint_keys = views.saveConstraint(
dict(hour_list=range(0, 24), dow_list=range(1, 8), slot=0))
views.connectConstraintsAndSpot(constraint_keys, spot_key)
spot_copy = models.SpotCopy(body='body', spot=spot, author=user)
spot_copy.put()
resp = self.client.get(reverse('traffic_log.index'))
context = resp.context[0]
spot_map = {}
constraint_map = {}
for c in context['slotted_spots']:
spot_map[c.hour] = list(c.iter_spots())[0]
constraint_map[c.hour] = c
now = time_util.chicago_now()
# first hour:
self.assertEqual(spot_map[now.hour].title, 'Legal ID')
# second hour:
self.assertEqual(
spot_map[(now + datetime.timedelta(hours=1)).hour].title,
'Legal ID')
def test_spot_copy(self):
author = User(email='test')
author.save()
spot = models.Spot(title='Legal ID', type='Station ID')
spot.put()
self.assertEqual(
spot.get_add_copy_url(),
reverse('traffic_log.views.addCopyForSpot', args=(spot.key(), )))
constraint = models.SpotConstraint(dow=1,
hour=0,
slot=0,
spots=[spot.key()])
constraint.put()
spot_copy = models.SpotCopy(
body=('You are now and forever listening to a killer '
'radio station called chirpradio.org'),
spot=spot,
author=author)
spot_copy.put()
self.assertEqual(
str(spot_copy),
"You are now and forever listening to a killer radio...")
self.assertEqual(
spot_copy.get_edit_url(),
reverse('traffic_log.editSpotCopy', args=(spot_copy.key(), )))
self.assertEqual(
spot_copy.get_delete_url(),
reverse('traffic_log.deleteSpotCopy', args=(spot_copy.key(), )))
def test_make_spot_copy_expire(self):
spot = models.Spot(title='Legal ID', type='Station ID')
spot.put()
constraint = models.SpotConstraint(dow=1,
hour=0,
slot=0,
spots=[spot.key()])
constraint.put()
author = User(email='test')
author.put()
spot_copy = models.SpotCopy(body='First', spot=spot, author=author)
spot_copy.put()
resp = self.client.post(
reverse('traffic_log.editSpotCopy', args=(spot_copy.key(), )),
{
'spot_key': spot.key(),
'body': 'Something else entirely',
'underwriter': 'another underwriter',
'expire_on': '2/5/2010' # any date in the past
})
self.assertNoFormErrors(resp)
spot_copy = [c for c in spot.all_spot_copy()]
self.assertEqual(spot_copy, [])
def test_delete_spot_copy(self):
spot = models.Spot(title='Legal ID', type='Station ID')
spot.put()
dow = 1
hour = 0
slot = 0
constraint = models.SpotConstraint(dow=dow,
hour=hour,
slot=slot,
spots=[spot.key()])
constraint.put()
author = User(email='test')
author.put()
spot_copy = models.SpotCopy(body='First', spot=spot, author=author)
spot_copy.put()
self.assertEqual(spot.get_spot_copy(dow, hour, slot)[0].body, "First")
# now edit the second one:
resp = self.client.get(
reverse('traffic_log.deleteSpotCopy', args=(spot_copy.key(), )))
self.assertEqual([c for c in spot.all_spot_copy()], [])
self.assertEqual(spot.get_spot_copy(dow, hour, slot), (None, False))
def signup():
form = SignupForm()
if form.validate_on_submit():
try:
hashed_password = generate_password_hash(form.password.data,
method='sha256')
new_user = User(username=form.username.data,
email=form.email.data,
password=hashed_password,
name=form.name.data,
address=form.address.data,
zip_code=form.zip_code.data,
city=form.city.data,
phone_no=form.phone_no.data)
# birth_date=form.birth_date.data)
db.session.add(new_user)
db.session.commit()
flash('User added successfully', 'success')
return redirect(url_for('home.index'))
# return render_template(signupTemplate, form=form, success=True, purpose="signup", action=url_for('auth.signup'), success_message='User added successfully')
except IntegrityError as e:
flash('User already exists in database', 'danger')
return render_template(signupTemplate,
form=form,
purpose="signup",
action=url_for('auth.signup'))
return render_template(signupTemplate,
form=form,
purpose="signup",
action=url_for('auth.signup'))
def test_update_non_profile_fields(self):
# Updated non-profile fields shouldn't result in the signal
u = User()
with test_utils.mock_handler(signals.user_profile_changed) as handler:
u.show_tutorial = False
u.save()
assert_false(handler.called)
def add_user(roles=None):
username = input('Enter username: '******'User with this username already exists'
email = input('Enter email address: ')
if email:
assert User.query.filter_by(
email=email).first() is None, 'User with this email already exists'
password = getpass('Enter password: '******'Password (again):'), 'Passwords do not match'
if roles is None:
roles = input(
'Enter roles to be assigned (comma separated; leave blank if `None`): '
)
roles = roles.split(',')
db_roles = Role.query.filter(Role.name.in_(roles)).all()
password_hash = encrypt_password(password)
user_data = Dict()
user_data.email = email
user_data.username = username
user_data.password = password_hash
user_data.active = True
user_data.roles = db_roles
user = User(**user_data)
db.session.add(user)
db.session.commit()
print('User added.')
def test_view_spot_for_reading_basic(self):
author = User(email='test')
author.save()
spot = models.Spot(title='Legal ID', type='Station ID')
spot.put()
constraint = models.SpotConstraint(dow=1,
hour=0,
slot=0,
spots=[spot.key()])
constraint.put()
spot_copy = models.SpotCopy(body='You are listening to chirpradio.org',
spot=spot,
author=author)
spot_copy.put()
resp = self.client.get(
reverse('traffic_log.spotTextForReading', args=(spot.key(), )), {
'hour': constraint.hour,
'dow': constraint.dow,
'slot': constraint.slot
})
context = resp.context
self.assertEqual(context['spot_copy'].body,
'You are listening to chirpradio.org')
self.assertEqual(
context['url_to_finish_spot'],
"/traffic_log/spot-copy/%s/finish?hour=0&dow=1&slot=0" %
spot_copy.key())
def post(self):
""" Login the user """
parser = reqparse.RequestParser()
parser.add_argument('username', type=str, required=True)
parser.add_argument('password', type=str, required=True)
reqdata = parser.parse_args(strict=True)
username = reqdata['username']
password = reqdata['password']
# Change this to check the user details against a database
if username != 'test' or password != 'test':
resp = jsonify({'login': False})
return make_response(resp, 401)
user = User(uuid='87', username='******', roles=['admin'])
access_token = create_access_token(identity=user)
refresh_token = create_refresh_token(identity=user)
resp = jsonify({'login': True})
set_access_cookies(resp, access_token)
set_refresh_cookies(resp, refresh_token)
return make_response(resp, 200)
def registration_controller(request):
errors = {}
is_valid = True
data = request.get('data')
if 'login' not in data:
errors.update({'login': '******'})
is_valid = False
if 'password' not in data:
errors.update({'password': '******'})
is_valid = False
if not is_valid:
response = make_response(request, 400, errors)
return response
hmac_obj = hmac.new(SECRET_KEY.encode(), data.get('password').encode())
password_digest = hmac_obj.digest()
with session_scope() as db_session:
user = User(name=data.get('login'), password=password_digest)
db_session.add(user)
token = login(request, user)
response = make_response(request, 200, {'token': token})
return response
def setUp(self):
# Initialize functional test framework
self.app = webtest.TestApp(self.router)
self.logout()
# Reset users
word = 'Спасибо'.decode('utf-8')
self.userS = ReplaceableDict() # Super
self.userA = ReplaceableDict() # Active
self.userI = ReplaceableDict() # Inactive
for userID, valueByKey in enumerate(
[self.userS, self.userA, self.userI], 1):
wordNumber = word + str(userID)
valueByKey['username'] = wordNumber
valueByKey['password'] = wordNumber
valueByKey['nickname'] = wordNumber
valueByKey['email'] = wordNumber + '@example.com'
valueByKey['is_active'] = userID != 3
valueByKey['is_super'] = userID == 1
user = User(id=userID,
username=valueByKey['username'],
password=valueByKey['password'],
nickname=valueByKey['nickname'],
email=valueByKey['email'],
is_active=valueByKey['is_active'],
is_super=valueByKey['is_super'])
db.merge(user)
transaction.commit()
def test_cannot_delete_someone_elses_track(self):
other_user = User(email="*****@*****.**")
other_user.roles.append(auth.roles.DJ)
other_user.put()
time.sleep(0.4)
other_track = PlaylistTrack(
playlist=self.playlist,
selector=other_user,
freeform_artist_name="Peaches",
freeform_track_title="Rock Show",)
other_track.put()
with fudge.patched_context(playlists.tasks, "_fetch_url", stub_fetch_url):
resp = self.client.get(reverse('playlists_delete_event',
args=[other_track.key()]))
self.assertRedirects(resp, reverse('playlists_landing_page'))
# simulate the redirect:
resp = self.client.get(reverse('playlists_landing_page'))
# should be no change:
context = resp.context[0]
tracks = [t.artist_name for t in context['playlist_events']]
self.assertEquals(tracks, ["Peaches", "Steely Dan"])
def index():
if g.user is None:
login_form = LoginForm(prefix="login")
registration_form = RegistrationForm(prefix="register")
button = request.form.get('button')
if button == 'login' and login_form.validate_on_submit():
user = login_form.user
user.touch()
session['username'] = user.username
return redirect(request.args.get('next', url_for('index')))
elif button == 'register' and registration_form.validate_on_submit():
count = User.query.count()
user = User(
registration_form.username.data,
generate_password_hash(registration_form.password.data),
registration_form.email.data,
False,
True,
bool(count == 0),
)
db.session.add(user)
db.session.flush()
email.send_account_created_email(user)
db.session.commit()
session['username'] = user.username
flash('Registration successful! Please check your e-mail so we can verify your address.')
return redirect(url_for('index'))
else:
return render_template('index.html',
login_form=login_form,
registration_form=registration_form)
else:
identity_tokens = list(g.user.identity_tokens.filter_by(enabled=True))
return render_template('index.html', identity_tokens=identity_tokens)
async def post(self):
data = await self.request.post()
login = data['login']
password = data['password']
retype_pass = data['retype_pass']
form_error = []
if len(login) < 3:
form_error.append("Login too small")
if await User.check_user(login):
form_error.append("Login exists")
if len(password) < 6:
form_error.append("Password too small")
if password != retype_pass:
form_error.append("Passwords not eq")
if len(form_error) > 0:
return {'form_error': form_error}
else:
user = User(data)
result = await user.create_user()
if isinstance(result, int):
session = await get_session(self.request)
set_session(session, str(result), self.request)
else:
return web.Response(content_type='application/json',
text=convert_json(result))
async def get(self):
ws = web.WebSocketResponse()
await ws.prepare(self.request)
session = await get_session(self.request)
user = User(self.request.app.db, {'id': session.get('user')})
login = await user.get_login()
for _ws in self.request.app['websockets']:
_ws.send_str('%s joined' % login)
self.request.app['websockets'].append(ws)
async for msg in ws:
if msg.type == WSMsgType.TEXT:
if msg.data == 'close':
await ws.close()
else:
message = Message(self.request.app.db)
result = await message.save(user=login, msg=msg.data)
log.debug(result)
for _ws in self.request.app['websockets']:
await _ws.send_str('{"user": "******", "msg": "%s"}' %
(login, msg.data))
elif msg.type == WSMsgType.ERROR:
log.debug('ws connection closed with exception %s' %
ws.exception())
self.request.app['websockets'].remove(ws)
for _ws in self.request.app['websockets']:
_ws.send_str('%s disconected' % login)
log.debug('websocket connection closed')
return ws
def setUp(self):
assert self.client.login(email="*****@*****.**",
roles=[roles.TRAFFIC_LOG_ADMIN])
author = User(email='test')
author.save()
self.author = author
spot = models.Spot(title='Legal ID', type='Station ID', author=author)
self.spot = spot
spot.put()
self.now = time_util.chicago_now()
self.today = self.now.date()
self.dow = self.today.isoweekday()
constraint = self.add_spot_to_constraint(spot)
self.constraint = constraint
spot_copy = models.SpotCopy(body='You are listening to chirpradio.org',
spot=spot,
author=author)
self.spot_copy = spot_copy
spot_copy.put()
spot.random_spot_copies = [spot_copy.key()]
spot.save()
logged_spot = models.TrafficLogEntry(log_date=self.today,
spot=spot_copy.spot,
spot_copy=spot_copy,
dow=self.dow,
hour=self.now.hour,
slot=0,
scheduled=constraint,
readtime=time_util.chicago_now(),
reader=author)
logged_spot.put()
def user_register(**kwargs):
# Validate incoming json
if kwargs.keys() != register_dict.keys():
abort(400, 'Invalid arguments')
username = kwargs.get('username')
password = kwargs.get('password')
# check if arguments are not empty
if username == '':
abort(400, 'field username cannot be empty')
if password == '':
abort(400, 'field password cannot be empty')
# Abort if user already exists
if User.query.filter(User.username == username).count() != 0:
abort(400, 'Username {} has already been taken'.format(repr(username)))
# 1. Creates new user according to request params
# 2. Add to db
# 3. Commit changes
new_user = User(username=username, password=password)
db.session.add(new_user)
db.session.commit()
# return new_user
resp = UserSchema().jsonify(new_user)
resp.status_code = 201
# Return code 201: 'Created'
return resp
def test_notifications_unicode(self):
self.assertEqual(len(mail.outbox), 0)
user = User(email=u'Leandro André[email protected]',
username='******')
user.set_password("secret")
user.save()
self.assertEqual(len(mail.outbox), 1)
def add_user(username,
password,
age,
sex,
department,
position,
mobile,
emergency_contact,
email,
perm=None):
if perm in [auth_enums.ACADEMY, auth_enums.BUSINESS, auth_enums.CLUSTER]:
status = auth_enums.USER_STATUS_NORMAL
else:
status = auth_enums.USER_STATUS_CHECK
user = User(card_id=str(make_card_id()),
username=username,
password=md5(password),
age=age,
sex=sex,
department=department,
position=position,
mobile=mobile,
emergency_contact=emergency_contact,
email=email,
perm=perm,
status=status)
user.save()
def test_user_edit_form_change_password(self):
steve = User(email='*****@*****.**',
first_name='Steve',
last_name='Dolfin',
dj_name='DJ Steve',
roles=['dj'],
is_active=True,
password='******')
steve.save()
resp = self.client.post(
'/auth/edit_user/',
{
'original_email': '*****@*****.**', # this is the key
'email': '*****@*****.**',
'first_name': 'Steve',
'last_name': 'Dolfin',
'dj_name': 'DJ Seteve',
'is_active': 'checked',
'is_dj': 'checked',
# new password
'password': '******'
})
self.assertNoFormErrors(resp)
user = User.all().filter('email =', '*****@*****.**').fetch(1)[0]
# password was changed:
self.assertEqual(user.check_password('1234567'), True)
