def after_login(resp):
if resp.email is None or resp.email == "":
flash(gettext('Invalid login. Please try again.'))
return redirect(url_for('login_view'))
user = User.query.filter_by(email = resp.email).first()
userdetails = UserDetails(user=user)
if user is None:
nickname = resp.nickname
if nickname is None or nickname == "":
nickname = resp.email.split('@')[0]
nickname = User.make_valid_nickname(nickname)
nickname = User.make_unique_nickname(nickname)
user = User(nickname = nickname, email = resp.email, role = ROLE_USER)
db.session.add(user)
db.session.add(userdetails)
db.session.commit()
# make the user follow him/herself
db.session.add(user.follow(user))
db.session.commit()
userdetails = UserDetails.query.filter_by(user=user).first()
if userdetails is None:
userdetails = UserDetails(user=user)
db.session.add(userdetails)
db.session.commit()
remember_me = False
if 'remember_me' in session:
remember_me = session['remember_me']
session.pop('remember_me', None)
login_user(user, remember = True)
return redirect(request.args.get('next') or url_for('main_flow.index'))
def oauth_callback(provider):
if not current_user.is_anonymous():
return redirect(url_for('simple_page.index'))
oauth = OAuthSignIn.get_provider(provider)
social_id, username, email = oauth.callback()
if social_id is None:
flash(getttext(u'Authentication failed'), 'danger')
return redirect(url_for('simple_page.index'))
# check if user exists and if no creates new
user = User.query.filter_by(social_id=social_id).first()
if user is None:
user = User(
username=username,
password='',
email=email,
social_id=social_id
)
db.session.add(user)
db.session.commit()
login_user(user, remember=True)
user.update_login_info()
return redirect(url_for('simple_page.index'))
def register():
"""
Registration Form
"""
form = RegisterForm(request.form)
if form.validate_on_submit():
# create an user instance not yet stored in the database
user = User(username=form.name.data,
email=form.email.data,
password=generate_password_hash(form.password.data)
)
#current_user=True)
# Insert the record in our database and commit it
try:
user.save()
except errors.NotUniqueError:
return render_template("users/register.html",
form=form,
duplicate=True,
user=None)
except:
raise
# Log the user in, as he now has an id
session['user_id'] = str(user.id)
session['user'] = user.username
print "session user_id: %s" % (str(user.id))
# flash will display a message to the user
#flash('Thanks for registering')
# redirect user to the 'home' method of the user module.
return redirect(url_for('users.home'))
return render_template("users/register.html", form=form, user=None)
def test_invalid_password_is_rejected(self):
User.create(name="Joe", email="*****@*****.**", password="******")
with self.client:
self.client.post("/login/", data={"name": "Joe", "password": "******"})
self.assertTrue(current_user.is_anonymous())
def setup_user(oauth_provider, oauth_id, display_name, image_url):
key = dict(
oauth_id = unicode(oauth_id),
oauth_provider = oauth_provider
)
slugs = set(u.display_slug for u in User.query.all())
user = User.query.filter_by(**key).first()
if not user:
user = User(**key)
db.session.add(user)
user.display_slug = slugify_unique(display_name, slugs)
user.display_name = display_name
user.oauth_token, user.oauth_secret = session['oauth']
# Load image
s = StringIO()
im = im_open(StringIO(req_get(image_url).content))
im.thumbnail((128, 128), ANTIALIAS)
im.save(s, 'JPEG')
user.image = s.getvalue()
db.session.commit()
login_user(user, remember = True)
# Why do i need this?
del session['oauth']
return redirect('/static/auth_recv.html')
def register():
email = request.form['email']
username = request.form['username']
password = request.form['password'].encode('utf8')
salt = generate_random_salt()
password_hash = generate_password_hash(password, salt)
# Check if email already exist in database
# if account does not exist create account in database
if User.objects(email=email).first() == None:
user = User(email=email)
user.accounts['internal'] = {"username":username, "password_hash":password_hash, \
"salt":salt}
user.save()
ret = json_util.dumps({"message":"account created", "status":"success"})
resp = Response(response=ret,
status=201,
mimetype="application/json")
return resp
else:
ret = json_util.dumps({"message":"Email already exist in database"})
resp = Response(response=ret,
status=200,
mimetype="application/json")
return resp
def login():
if request.method == 'POST':
user = User(name=request.form['username'], passwd = request.form['passwd'])
if user.is_active():
login_user(user)
redirect(url_for('frontend.home'))
redirect(url_for('frontend.login'))
def create_test_user():
user = User()
user.vk_id = "24076752"
user.access_token = "GsPlUf1RVH8AAAAAAAAAAQIpLzXXVtywxpD90ySk8XbSsFO5DoU0dhOlGU4qU5Fc"
user.expires = datetime.datetime.now() + datetime.timedelta(days=100)
db.session.add(user)
db.session.commit()
def create():
args = ['username', 'realname', 'email', 'pw', 'phone']
result = ''
try:
for i in args:
assert i in request.args, 'missing ' + i
assert len(list(graph_db.find("User","username",request.args['username']))) == 0, "user already exists"
assert len(list(graph_db.find("User","email",request.args['email']))) == 0, "email already exists"
u = User(username=request.args['username'],
realname=request.args['realname'],
email=request.args['email'],
password=hash_pw(request.args['pw']),
phone=request.args['phone'])
while True:
u.userid = randint(app.config['UID_START'],app.config['UID_END'])
if len(list(graph_db.find("User","id",u.userid))) == 0: break
u.save()
result = "user %s created" % u.userid
except AssertionError, e:
result = str(e)
def test_users_can_logout(self):
User.create(name="Joe", email="*****@*****.**", password="******")
with self.client:
self.client.post("/login/", data={"name": "Joe", "password": "******"})
self.client.get("/logout/")
self.assertTrue(current_user.is_anonymous())
def add_admin():
"""Adds admin to database"""
admin = User.query.filter_by(username="******").first()
if admin is None:
new_admin = User("admin", generate_password_hash("supertajnehaslo"), "*****@*****.**", social_id=None)
new_admin.role = USER.ADMIN
new_admin.confirmed = True
db.session.add(new_admin)
db.session.commit()
def test_users_can_login(self):
User.create(name="Joe", email="*****@*****.**", password="******")
with self.client:
response = self.client.post("/login/", data={"name": "Joe", "password": "******"})
self.assert_redirects(response, url_for("index"))
self.assertTrue(current_user.name == "Joe")
self.assertFalse(current_user.is_anonymous())
def test_make_unique_name(self):
user = User(name='john', email='*****@*****.**')
db.session.add(user)
db.session.commit()
name = User.make_unique_name('john')
self.assertEqual(name, 'john2')
# use the new name
user = User(name=name, email='*****@*****.**')
db.session.add(user)
db.session.commit()
new_name = User.make_unique_name('john')
self.assertEqual(new_name, 'john3')
def add_users():
form = AddUserForms(request.form)
all_users = User.query.all()
form.select_role.choices = [(role.id, role.name) ## Loads up choices
for role in Role.query.all()]
## load roles that had supervisor roles in it:
form.select_supervisor.choices = [(user.username, user.username)
for user in User.query.all() if user.is_supervisor]
print form.select_role.choices
if form.validate_on_submit():
password = generate_password_hash('seer')
u = User (form.fname.data,form.midname.data,form.lname.data, ## Load user
form.email.data,form.username.data,password)
print form.select_role.data
for i in form.select_role.data: ## Loads up the selected choices of the user
print i
u.role.append(Role.query.get(i))
print u.role
##Checks if the user is a supervisor
if form.check_if_supervisor.data:
u.is_supervisor = True
## Loads up the supervisor of the user, and loads up the user to its supervisor
u.supervisor = form.select_supervisor.data
print form.select_supervisor.data
supervisor = User.query.filter_by(username=form.select_supervisor.data).first()
if supervisor.supervisee is None or '':
supervisor.supervisee = u.username
print supervisor.supervisee
else:
supervisor.supervisee = supervisor.supervisee + ' ' + u.username
print supervisor.supervisee
db_session.add(u)
db_session.add(supervisor)
db_session.commit()
us = UserStatistics(userId=u.id)
us.sl = form.number_of_sick_leaves.data
us.vl = form.number_of_vacation_leaves.data
us.offset = 0
db_session.add(us)
db_session.commit()
flash('User Created')
return redirect(url_for('Users.add_users'))
return render_template('admin/add_user.html', form = form)
def register_view():
form = RegistrationForm(request.form)
if form.validate_on_submit():
user = User()
form.populate_obj(user)
user.initials = user.initials.upper()
user.generate_password_hash(user.password)
session.add(user)
session.commit()
login_user(user)
return redirect(url_for('index'))
return render_template('users/register.html', form=form)
def createUser():
try:
details = getUserDetails()
user = User(details['name'], details['gplusId'])
db.session.add(user)
db.session.commit()
user.apiToken = user.getAPIToken()
db.session.merge(user)
db.session.commit()
createDummyPage(user.gplusId)
#return redirect(url_for(profile))
except Exception, e:
print e
def post(self):
user = User()
user.user_name = request.json_data['username']
user.set_password(request.json_data['password'])
db.session.add(user)
db.session.commit()
resp = jsonify(user.serialize())
resp.status_code = 201
return resp
def test_follow(self):
user1 = User(name='mark', email='*****@*****.**')
user2 = User(name='rudy', email='*****@*****.**')
db.session.add(user1)
db.session.add(user2)
db.session.commit()
self.assertEqual(user1.is_following(user2), False)
self.assertEqual(user1.unfollow(user2), None)
user1 = user1.follow(user2)
db.session.add(user1)
db.session.commit()
# user1 has already followed user2
self.assertEqual(user1.follow(user2), None)
self.assertEqual(user1.followed.count(), 1)
self.assertEqual(user1.followed.first().name, 'rudy')
self.assertEqual(user2.followers.count(), 1)
self.assertEqual(user2.followers.first().name, 'mark')
user1 = user1.unfollow(user2)
db.session.add(user1)
db.session.commit()
self.assertEqual(user1.unfollow(user2), None)
self.assertEqual(user1.is_following(user2), False)
self.assertEqual(user1.followed.count(), 0)
self.assertEqual(user2.followers.count(), 0)
def get(self, request):
users = User.get_users(status=None)
projects = Project.get_projects()
return render(request, "index.html", {
"users": serializers.serialize('json', users),
"projects": serializers.serialize('json', projects),
})
def dispatch_request(self):
try:
user = request.form['userEmail']
title = request.form['missionTitle'].encode('utf-8')
contents = request.form['missionContents'].encode('utf-8')
difficulty = request.form['missionDifficulty']
effect = request.form['missionEffect']
effect = int(float(effect))
difficulty = int(float(difficulty))
m = Mission(title, contents, difficulty, effect)
m.push_data()
m = Mission.get_mission(title)
u = User.find_by_email(user)
ms = MissionState(u.id, m.id, '1')
ms.push_data()
response = Lusponse.make_success_response('success make missions', '')
return response
except Exception, e:
response = Lusponse.make_fail_response('fail make missions', "%r"%e)
return response
def signup():
if current_user.is_authenticated():
flash(gettext('You are already signed in.'))
return redirect(url_for('index'))
form = SignUpForm()
if form.validate_on_submit():
try:
## Create user from the form
user = User.create()
form.populate_obj(user)
user.set_password(form.password.data)
user.last_seen = datetime.datetime.utcnow()
user.last_login = datetime.datetime.utcnow()
## Store in database
user.save()
## Login User
login_user(user)
flash(gettext('Welcome! You have signed up successfully.'))
return redirect(url_for('index'))
except:
flash(gettext('Error while saving the new user, please retry later'), 'error')
return render_template('admin/signup.html',
title = gettext('Sign Up'),
form = form)
def login():
if current_user.is_authenticated():
flash(gettext('You are already signed in.'))
return redirect(url_for('index'))
form = LoginForm()
if form.validate_on_submit():
try:
user = User.find_by_email(form.email.data)
if (user is not None) and (user.check_password(form.password.data)):
login_user(user)
# Update the User's info
user.last_login = user.last_seen
user.last_seen = datetime.datetime.utcnow()
user.save()
redirect_to = url_for('dashboard')
if 'redirect_to' in session:
redirect_to = session['redirect_to']
session.pop('redirect_to', None)
flash(gettext('Signed in successfully.'))
return redirect(redirect_to)
else:
raise Exception(gettext('User not found or invalid password'))
except:
flash(gettext('Invalid email or password'), 'error')
return render_template('admin/signin.html',
title = gettext('Sign In'),
form = form)
def CreateComment():
if request.method=='GET':
return json.dumps({'message':'Please use method POST!'})
if request.method=='POST':
token=request.values.get('token')
if token is None:
return json.dumps({'message':'Need Token!'})
user=User.verify_auth_token(token)
if type(user) is types.StringType:
return json.dumps({'message':user})
if request.values.get('DishID') is None:
return json.dumps({'message':'Need DishID!'})
if YMDish.query.filter(YMDish.DishID==request.values.get('DishID')).all() is None:
return json.dumps({'message':'DishID is invalid!'})
if request.values.get('Content') is None:
return json.dumps({'message':'Need Content!'})
else:
ym_dish_comments=YMDishComment(UserName=user.UserName,DishID=request.values.get('DishID')
,Time=time.strftime('%Y-%m-%d %H:%M:%S',time.localtime(time.time()))
,Content=request.values.get('Content'))
try:
ym_dish_comments.save()
except:
return json.dumps({'message':'Comment Existed!'})
return json.dumps({'message':'Add Comment Success!'})
def auth():
response = _get_token()
data = _get_data(response)
user = User.get_or_create(data)
login_user(user)
return redirect(request.args.get('next') or url_for('users.home'))
def post(self):
resp = request.get_json()
avatar = resp.get('avatar')
email = resp.get('email')
username = resp.get('username')
first_name = resp.get('first_name') or ''
last_name = resp.get('last_name') or ''
password = resp.get('password')
gender = resp.get('gender') or ''
user = User.create(
avatar=avatar,
email=email,
first_name=first_name,
gender=gender,
last_name=last_name,
password=password,
username=username,
created=datetime.datetime.now(),
last_login=datetime.datetime.now(),
activated=False,
)
return Response(json.dumps(user.serialize), mimetype='application/json')
def GetLikeDish():
if request.method=='GET':
return json.dumps({'message':'Please use method POST!'})
if request.method=='POST':
token=request.values.get('token')
if token is None:
return json.dumps({'message':'Need Token!'})
user=User.verify_auth_token(token)
if type(user) is types.StringType:
return json.dumps({'message':user})
like_diskes=db.session.query(YMDish).join(LikeDish).filter(LikeDish.UserName==user.UserName).all()
List=[]
for one in like_diskes:
List.append({'DishID':one.DishID
,'DishType':one.DishType
,'DishSmallImage':one.DishSmallImage
,'DishLargeImage':one.DishLargeImage
,'DishName':one.DishName
,'Taste':one.Taste
,'RawStuff':one.RawStuff
,'Locations':one.Locations
,'Description':one.Description
,'Price':str(one.Price)
,'Like':one.Like
,'Favorite':one.Favorite})
return json.dumps({'Dish_List':json.dumps(List)})
def test_visitors_location_is_derived_from_ip(self):
user = User.create(name="Joe", email="*****@*****.**", password="******")
site = Site.create(user_id=user.id)
mock_geodata = Mock(name="get_geodata")
mock_geodata.return_value = {
'city': 'Los Angeles',
'zipcode': '90001',
'latitude': '34.05',
'longitude': '-118.25'
}
url = url_for("tracking.register_visit", site_id=site.id)
wsgi_environment = {"REMOTE_ADDR": "1.2.3.4"}
with patch.object(app.tracking.views, "get_geodata", mock_geodata):
with self.client:
self.client.get(url, environ_overrides=wsgi_environment)
visits = Visit.query.all()
mock_geodata.assert_called_once_with("1.2.3.4")
self.assertEquals(1, len(visits))
self.assertEquals("Los Angeles, 90001", visits[0].location)
self.assertEquals("Los Angeles, 90001, 34.05, -118.25",
visits[0].location_full)
def get(self):
# get all user
user_list = list()
for user in User.select():
user_list.append(user.serialize)
return Response(json.dumps(user_list, indent=4), mimetype='application/json')
class TimerTest(TestCase):
ARRIVED_AT = timezone.make_aware(datetime(2015, 10, 1, 9, 50))
LEFT_AT = timezone.make_aware(datetime(2015, 10, 1, 19, 30))
def setUp(self):
self.user = User(name="test")
self.user.save()
def test_arrived(self):
manager = TimeManager(self.user)
manager.arrived(self.ARRIVED_AT)
day_log = DayLog.find_or_create(self.user, self.ARRIVED_AT.date())
timer_logs = TimerLog.findAll(self.user, self.ARRIVED_AT.date())
self.assertEqual(day_log.arrived_at, self.ARRIVED_AT)
self.assertEqual(len(timer_logs), 1)
self.assertEqual(timer_logs[0].action_type, TimerLog.ARRIVED)
self.assertEqual(timer_logs[0].time, self.ARRIVED_AT)
def test_left(self):
manager = TimeManager(self.user)
manager.left(self.LEFT_AT)
day_log = DayLog.find_or_create(self.user, self.LEFT_AT.date())
timer_logs = TimerLog.findAll(self.user, self.LEFT_AT.date())
self.assertEqual(day_log.left_at, self.LEFT_AT)
self.assertEqual(len(timer_logs), 1)
self.assertEqual(timer_logs[0].action_type, TimerLog.LEFT)
self.assertEqual(timer_logs[0].time, self.LEFT_AT)
def test_arrive_and_left(self):
manager = TimeManager(self.user)
manager.arrived(self.ARRIVED_AT)
manager.left(self.LEFT_AT)
day_log = DayLog.find_or_create(self.user, self.ARRIVED_AT.date())
timer_logs = TimerLog.findAll(self.user, self.ARRIVED_AT.date())
self.assertEqual(day_log.arrived_at, self.ARRIVED_AT)
self.assertEqual(day_log.left_at, self.LEFT_AT)
self.assertEqual(day_log.work_time, 520)
self.assertEqual(len(timer_logs), 2)
def login():
"""
Login page with form (handled on POST).
"""
form = LoginForm(request.form)
if request.method == "POST" and _validate_login_form(form):
return redirect(url_for("users.home"))
return render_template("users/login.html", form=form, is_admin=User.is_admin(g.user))
def create_user():
user = User(email='*****@*****.**', firstname='fn', lastname='ln')
user.set_password('password')
db.session.add(user)
db.session.commit()
return user
def invite_user():
form = InviteUserForm()
if form.validate_on_submit():
submitted_login = form.login.data.strip().replace(' ', '')
user = get_user_by_login(submitted_login)
if not user:
invited_user = User()
is_phone_number = False
try:
phonenumber = phonenumbers.parse(form.login.data)
is_phone_number = True
except phonenumbers.phonenumberutil.NumberParseException as error:
pass
invited_user.first_name = form.first_name.data.strip()
invited_user.last_name = form.last_name.data.strip()
hashed_password = bcrypt.generate_password_hash(
form.password.data).decode('utf-8')
invited_user.password = hashed_password
invited_user.is_active = True
if is_phone_number:
invited_user.mobile_phone = form.login.data
invited_user.prayer_requests_by_sms = True
log_in = invited_user.mobile_phone
else:
invited_user.email = form.login.data
invited_user.prayer_requests_by_email
log_in = invited_user.email
invited_user.invited_at = datetime.utcnow()
invited_user.invited_by = current_user.id
db.session.add(invited_user)
db.session.commit()
send_invitation(log_in, is_phone_number, form.password.data,
invited_user, current_user)
flash(
f'The invitation was sent to {invited_user.first_name} {invited_user.last_name}',
'info')
return redirect(url_for('main.home'))
else:
flash('A user with that login information already exists.', 'info')
return render_template('invite.html', form=form)
def create_albumns2():
nu1 = User(firstname='f', lastname='l', email='*****@*****.**')
nu1.set_password('test')
db.session.add(nu1)
db.session.commit()
nu2 = User(firstname='f2', lastname='l2', email='*****@*****.**')
nu2.set_password('test')
db.session.add(nu2)
db.session.commit()
DisplayStatus.add_default_display_status()
# user 1
u1albumu1 = Album.create_album(user_pk=nu1.pk,
name='album1',
cover_image='google.com')
u1albumu2 = Album.create_album(user_pk=nu1.pk,
name='album2',
cover_image='google.com')
u1albumu3 = Album.create_album(user_pk=nu1.pk,
name='album3',
cover_image='google.com')
pp = Playlist.create_playlist(nu1.pk,
name='playlist1',
cover_image='google.com',
display_status=3)
unlisted = Playlist.create_playlist(nu1.pk,
name='playlist2',
cover_image='google.com',
display_status=2)
user_private = Playlist.create_playlist(nu1.pk,
name='playlist_p',
cover_image='google.com',
display_status=1)
# user 2
u2albumu1 = Album.create_album(user_pk=nu1.pk,
name='album21',
cover_image='google.com')
u2albumu2 = Album.create_album(user_pk=nu1.pk,
name='album22',
cover_image='google.com')
u2albumu3 = Album.create_album(user_pk=nu1.pk,
name='album23',
cover_image='google.com')
newsong = Song(name='song1', user=nu2.pk, mp3_file='google.com')
db.session.add(newsong)
newsong = Song(name='song2', user=nu2.pk, mp3_file='google.com')
db.session.add(newsong)
newsong = Song(name='song3', user=nu1.pk, mp3_file='google.com')
db.session.add(newsong)
newsong = Song(name='song4', user=nu1.pk, mp3_file='google.com')
db.session.add(newsong)
newsong = Song(name='song5', user=nu1.pk, mp3_file='google.com')
db.session.add(newsong)
db.session.commit()
u1albumu1.add_song(1)
u1albumu1.add_song(2)
u1albumu1.add_song(3)
u2albumu1.add_song(4)
u2albumu2.add_song(5)
# -*- coding: utf-8 -*-
from app.users.models import User
USERS_URL_PREFIX = '/users'
USERS_BASE_TPL = 'base.html'
# TODO: this dict should be redundant if the users app will use a database
USERS = {
'admin':
User( # usersname
'admin', # usersname
'admin123', # password
1 # id
)
}
USERS_CURRENT = None
USERS_REDIRECT_LOGIN = '******'
USERS_REDIRECT_LOGOUT = 'simplepages.index'
def before_request():
g.user = None
if 'user_id' in session:
g.user = User.objects(id=session['user_id']).first()
def test_user_get_absolute_url(user: User):
"""[summary]
test user models return correct get_absolute_url()
"""
assert user.get_absolute_url() == f"/users/{user.id}/"
def load_user(user_id):
return User.objects(id=user_id).first()
