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()