def setUp(self):
db.create_all()
user1 = User("Elie", "Schoppik")
user2 = User("Tim", "Garcia")
user3 = User("Matt", "Lane")
db.session.add_all([user1, user2, user3])
message1 = Message("Hello Elie!!", 1)
message2 = Message("Goodbye Elie!!", 1)
message3 = Message("Hello Tim!!", 2)
message4 = Message("Goodbye Tim!!", 2)
db.session.add_all([message1, message2, message3, message4])
db.session.commit()
def test_user_columns(db_handle):
'''
id = db.Column(db.Integer, primary_key=True)
firstname = db.Column(db.String(30))
lastname = db.Column(db.String(30))
email = db.Column(db.String(100))
isAdmin = db.Column(db.Boolean, nullable=False)
creationdate = db.Column(db.DateTime)
courses = db.relationship("TrainingCourse",secondary=courseuserrelation,back_populates="users")
'''
print("App+Db test, test user columns")
#test user has isAdmin flag set
user = User()
db_handle.session.add(user)
with pytest.raises(IntegrityError):
db_handle.session.commit()
db_handle.session.rollback()
user = User()
user.isAdmin = True
db_handle.session.add(user)
db_handle.session.commit()
db_handle.session.rollback()
user = User()
user.isAdmin = True
user.firstname = 'testi1'
user.lastname = 'testi2'
user.email = 'testemail@com'
db_handle.session.add(user)
db_handle.session.commit()
print("test user update and delete")
print(user.id)
getuser = User.query.filter_by(id=user.id).first()
assert getuser.firstname == 'testi1'
getuser.firstname = 'nameedited'
db_handle.session.add(getuser)
db_handle.session.commit()
getuser2 = User.query.filter_by(id=getuser.id).first()
with pytest.raises(AssertionError):
assert getuser2.firstname == 'nameeditedwrong'
db_handle.session.delete(getuser2)
db_handle.session.commit()
getuser3 = User.query.filter_by(id=getuser2.id).first()
#check if deleted
with pytest.raises(AttributeError):
assert getuser3.firstname == 'nameedited'
def createUsers():
# Create Users
admin = User(username='******', password='******', admin=True)
user1 = User(username='******', password='******')
user2 = User(username='******', password='******')
db.session.add(admin)
db.session.add(user1)
db.session.add(user2)
db.session.commit()
return [user1, user2]
def setUp(self):
app.config[
"SQLALCHEMY_DATABASE_URI"] = 'postgres://localhost/warbler_test_db'
db.create_all()
user1 = User(username="******",
email="*****@*****.**",
password="******")
user2 = User(username="******",
email="*****@*****.**",
password="******")
db.session.add_all([user1, user2])
db.session.commit()
def test_bookmark(self):
u = User("testuser", "*****@*****.**", "test1234")
u2 = User("testuser2", "*****@*****.**", "test1234")
db.session.add(u)
db.session.add(u2)
title = "Overexpression of Topoisomerase 2-Alpha Confers a Poor Prognosis in Pancreatic Adenocarcinoma Identified by Co-Expression Analysis."
abstract = "abstract"
pubmed_id = "28815403"
doi = "10.1007/s10620-017-4718-4"
ref = Reference(title=title,
abstract=abstract,
pubmed_id=pubmed_id,
doi=doi)
db.session.add(ref)
db.session.commit()
bookmark = Bookmark(comment="TOPII ref")
bookmark.reference = ref
bookmark.user = u
db.session.add(bookmark)
db.session.commit()
self.assertEqual(len(u.bookmarks), 1)
title2 = "another ref"
abstract2 = "abstract"
pubmed_id2 = "28815404"
doi2 = "10.1007/s10620-037-4718-4"
ref2 = Reference(title=title2,
abstract=abstract2,
pubmed_id=pubmed_id2,
doi=doi2)
db.session.add(ref2)
db.session.commit()
bookmark2 = Bookmark(comment="another ref")
bookmark2.user = u
bookmark2.reference = ref2
db.session.add(bookmark2)
db.session.commit()
self.assertEqual(len(u.bookmarks), 2)
self.assertEqual(u.bookmarks[0].comment, "TOPII ref")
self.assertEqual(u.bookmarks[1].comment, "another ref")
bookmark3 = Bookmark(comment="another comment")
bookmark3.user = u2
bookmark3.reference = ref2
db.session.add(bookmark3)
db.session.commit()
self.assertEqual(len(u2.bookmarks), 1)
self.assertEqual(u2.bookmarks[0].comment, "another comment")
self.assertEqual(len(ref.bookmarks), 1)
self.assertEqual(len(ref2.bookmarks), 2)
def test_create_users_negative(db_handle):
# test that invalid users can't be added to the database
users = [
User(),
User(user_token="token", user_name=None, user_identifier="ping"),
User(user_token=None, user_name="user_name", user_identifier="ping"),
User(user_token="token", user_name="user_name", user_identifier=None)
#User(user_token="a" * 120, user_name="user_name"), # do we want to enforce the lenght of columns? https://stackoverflow.com/questions/2317081/sqlalchemy-maximum-column-length
]
for user in users:
with pytest.raises(IntegrityError):
db_handle.session.add(user)
db_handle.session.commit()
db_handle.session.rollback()
def userFunctions(fs):
""" test function for class functionality (not needed for production) """
user_info = {}
if "id" in fs:
if fs['id'] == 'login':
""" create a json object noting user_info """
valid_user = User(fs).isValidUser()
if valid_user:
user_info = User(fs).getUserCookie()
elif fs['id'] == 'profile':
user_info = User(fs).getUserCookie()
elif fs['id'] == 'tr':
user_info = User(fs).getUserTrackRecord()
returnJson(user_info)
def init_data():
tom = User(username='******', age=30, password='******')
bob = User(username='******', age=27, password='******')
lucy = User(username='******', age=24, password='******')
lily = User(username='******',age=26, password='******')
alex = User(username='******', age=91, password='******')
john = User(username='******', age=29, password='******')
jack = User(username='******', age=23, password='******')
tomas = User(username='******', age=18, password='******')
eva = User(username='******', age=21, password='******')
ella = User(username='******', age=23, password='******')
db.session.add_all([tom, bob, lucy, lily, alex, john, jack, tomas, eva, ella])
db.session.commit()
def init_data():
tom = User(name='tom', gender='male', password=123456)
bob = User(name='bob', gender='male', password=123456)
lucy = User(name='lucy', gender='female', password=123456)
lily = User(name='lily', gender='female', password=123456)
alex = User(name='alex', gender='male', password=123456)
john = User(name='john', gender='male', password=123456)
jack = User(name='jack', gender='male', password=123456)
tomas = User(name='tomas', gender='male', password=123456)
eva = User(name='eva', gender='female', password=123456)
ella = User(name='ella', gender='female', password=123456)
db.session.add_all(
[tom, bob, lucy, lily, alex, john, jack, tomas, eva, ella])
db.session.commit()
def setUp(self):
app.config[
"SQLALCHEMY_DATABASE_URI"] = 'postgres://localhost/warbler_test_db'
db.create_all()
user1 = User(username="******",
email="*****@*****.**",
password="******")
user2 = User(username="******",
email="*****@*****.**",
password="******")
msg1 = Message(text="rithmrithm I was here", user_id=user1.id)
msg2 = Message(text="Its a good good day", user_id=user2.id)
db.session.add_all([msg1, msg2, user1, user2])
db.session.commit()
def setUp(self):
db.create_all()
user1 = User("Elie", "Schoppik", "image")
user2 = User("Tim", "Garcia", "image")
user3 = User("Matt", "Lane", "image")
db.session.add_all([user1, user2, user3])
message1 = Message("Hello Elie!!", 1)
message2 = Message("Goodbye Elie!!", 1)
message3 = Message("Hello Tim!!", 2)
message4 = Message("Goodbye Tim!!", 2)
db.session.add_all([message1, message2, message3, message4])
email1 = Email("*****@*****.**", 1)
email2 = Email("*****@*****.**", 2)
db.session.add_all([email1, email2])
db.session.commit()
def submitUserInfo(fs):
""" submit user info to database """
returnObj = {'error': ''}
if 'oper' in fs:
uInfo = User(fs).updateUser()
else:
uInfo = User(fs).submitUser()
# handle return values
if uInfo['user_id'] != 0:
returnObj = uInfo
else:
returnObj['error'] = uInfo['message']
returnJson(returnObj)
def newinfluencer(
): #Creates a new influencer with blank information from the request form
if db['influencers'].find_one({'user': request.form['user']
}) is None and db['advertisers'].find_one(
{'user': request.form['user']}) is None:
new_influencer = Influencer(
name=escape(
request.form['name']
), #NewInfluencer has the tag as 'name', but when you inspect it's still fname?
username=request.form['user'],
password=request.form['pass'], #generates hash in __init__()
email=escape(request.form['email']),
desc='No description',
img='/static/images/default_profile_image.png',
insta='No Instagram',
yt='No Youtube',
tw='No Twitter',
tags='',
votes={})
db['influencers'].insert_one(new_influencer.to_dict(
)) #Adds the profile to db, needs to be a dict
use = User.User(username=new_influencer.username
) #Sets the user to the newly created user
login_user(use) #Logins in through Flask's LoginManager
return redirect('/influencerprofile') #Redirects to their profile
else:
return 'That username is in use'
def login_post():
email = request.form.get('email')
password = request.form.get('password')
remember = True if request.form.get('remember') else False
if not password or not email:
flash("Заполните все поля.")
return redirect(url_for('auth.login'))
token = get_auth_token(email, password)
if "non_field_errors" in token:
flash(token['non_field_errors'][0])
return redirect(url_for('auth.login'))
user = User.query.filter_by(username=email).first()
if user is None:
user = User(username=email, password=password)
user.token = pickle.dumps(token)
with db.session.no_autoflush:
db.session.add(user)
db.session.commit()
login_user(user, remember=remember)
return redirect(url_for('index'))
def __init__(self, form):
# Получаем данные из формы.
user_name = form.user_name.data
user_last_name = form.user_last_name.data
user_nic = form.user_nic.data
email = form.email.data
password = form.password.data
password_2 = form.password_2.data
# Хэшируем пароль пользователя.
password = generate_password_hash(password)
# Добавляем пользователвля в базу данных.
user_info = User(name=user_name,
last_name=user_last_name,
user_nic=user_nic,
email=email,
password=password)
try:
db.session.add(user_info)
db.session.commit()
print('Пользователь добавлен в базу')
except ValueError:
print('error')
try:
# Создаем отдельную папку для загрузки фото
os.chdir('./static/') # Переходи в нужную директорию.
# Создаем папку, для имени папки используем ник и email пользователя.
# ник и email берем из формы.
os.mkdir(f"{user_nic}-{email}")
# Оповещаем пользователя о успешной регистрации.
Message_info(email)
except OSError:
pass
def signup_post():
email = request.form.get('email')
email_re = request.form.get('emailre')
username = request.form.get('username')
password = request.form.get('password')
password_re = request.form.get('passwordre')
u = User.query.filter_by(email=email).first()
# if the signup form is not well completed
if u or email_re != email or password_re != password:
if u:
flash('Email address already in use!')
if email != email_re:
flash("Emails don't match!")
if password != password_re:
flash("Passwords don't match!")
return redirect(url_for('auth.signup'))
# create new user
new_user = User(username=username,
email=email,
password=generate_password_hash(password, method='sha256'))
# add the new user
db.session.add(new_user)
db.session.commit()
return redirect(url_for('auth.login'))
def register():
data = {
'uname': '请输入用户名',
'pass': '******',
'emai': '请输入邮箱',
}
if request.method == 'POST':
username = request.form.get('username')
password = request.form.get('password')
email = request.form.get('email')
if username != ('' and None) and password != (
'' and None) and email != ('' and None):
user = User.query.filter_by(username=username).first()
emai = User.query.filter_by(email=email).first()
if user:
data['uname'] = '该用户名已存在'
elif len(password) < 4:
data['pass'] = '******'
elif emai:
data['emai'] = '该邮箱已被注册'
else:
u = User(username=username, password=password, email=email)
u.save()
token = u.make_active_token()
sync(u.email,
'账号激活',
'active',
username=u.username,
token=token)
flash('注册成功，请接收邮件激活账号再登录!')
return redirect(url_for('index'))
return render_template('register.html', data=data)
def regist():
mail = request.form.get('mail')
name = request.form.get('name')
id_vk = request.form.get('id_vk')
hostel = request.form.get('hostel')
password = request.form.get('password')
password2 = request.form.get('password2')
if request.method == 'POST':
if not (mail or name or id_vk or hostel or password or password2):
flash('ВВЕДИТЕ ВСЕ ДАННЫЕ')
elif password2 != password:
flash('ВАШИ ПАРОЛИ НЕ ИДЕНТИЧНЫ')
else:
hash_pwd = generate_password_hash(password)
new_User = User(mail=mail,
name=name,
id_vk=id_vk,
hostel=hostel,
password=hash_pwd)
db.session.add(new_User)
db.session.commit()
return redirect(url_for('loginging'))
return render_template('registration_page.html')
def post(self):
'''Create new user.'''
args = parser.parse_args()
name = args['name']
passwd = args['password']
if not name or not passwd:
return {"message": "Provide your name and password!!"}, 400
hashed_password = generate_password_hash(passwd, method='sha256')
if User.query.filter_by(name=name).first():
return {"message": "Username taken!!"}, 409
new_user = User(public_id=str(uuid.uuid4()),
name=name,
password=hashed_password)
db.session.add(new_user)
db.session.commit()
response = jsonify({"message": "Registration successful."})
response.status_code = 201
return response
def _populate_db():
for i in range(1, 4):
u = User(
username="******".format(i)
)
db.session.add(u)
db.session.commit()
def adduser():
if not current_user.is_admin:
flash('You are no admin...')
return redirect(url_for('users'))
form = EditProfileForm('Dummy Username')
if form.validate_on_submit():
user = User.query.filter_by(username=form.username.data).first()
if user is not None:
flash('Please use a different username')
return redirect(url_for('adduser'))
user = User.query.filter_by(email=form.email.data).first()
if user is not None:
flash('Please use a different emailaddress')
return redirect(url_for('adduser'))
user = User(username=form.username.data,
email=form.email.data,
about_me=form.about_me.data,
is_admin=form.is_admin.data,
last_seen=None)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
## user.is_admin = request.form.get ('is_admin') == 'y'
flash('Your changes have been saved.')
return redirect(url_for('users', id=user.id))
return render_template('editprofile.html', tile='Edit profile', form=form)
def register():
if request.json == None or not all([x in request.json for x in ['name', 'college', 'department', 'email', 'year', 'phone_number', 'gender', 'pronouns', 'description', 'password']]):
return jsonify({'error': 'missing info'})
# if already registered
user = User.query.filter_by(email=request.json['email']).first()
if user != None:
return jsonify({'error': 'this email has already been registered'})
u = User(
name=request.json['name'],
college=request.json['college'],
department=request.json['department'],
email=request.json['email'],
year=request.json['year'],
phone_number=request.json['phone_number'],
gender=request.json['gender'],
pronouns=request.json['pronouns'],
description=request.json['description'],
password=request.json['password']
# password=bcrypt.hashpw(request.json['password'].encode('utf8'), bcrypt.gensalt()).decode('utf8'),
)
db.session.add(u)
db.session.commit()
print("new user:", u.id)
session['user_id'] = u.id
return jsonify({'status': 'register success', 'user_id': u.id})
def user(session):
new_user = User(email=fake.email(),
password=fake.sentence(),
username=fake.user_name())
session.add(new_user)
session.commit()
return new_user
def insert_data():
first_name = input("please enter your first name")
last_name = input("please enter your last name")
mail = input("please enter your email address")
notify_input = input(
"please enter 1 if you want to get notification every time an item is uploaded or 0 for once a day"
)
# notify_input = check_input(notify_input, int)
user = User(first_name=first_name,
last_name=last_name,
email=mail,
notify=notify_input)
db.session.add(user)
db.session.commit()
print(
"please enter the items you are looking for and the maximum price for each item"
)
items_list = []
while "*" != input("press * when finished"):
item_name = input("enter the item name")
item_price = input("maximum price for " + item_name)
item = Item(name=item_name, max_price=item_price)
items_list.append(item)
db.session.add(item)
db.session.commit()
search = Search(user_id=user.id, items=items_list)
db.session.add(search)
db.session.commit()
def login():
print('in server route login')
if request.method == 'POST':
print('in server route login POST')
if request.args.get('securityStamp'):
userDB = studentGrouped.getUserFromSecurityStamp(
str(request.args.get('securityStamp')))
if userDB is not None:
user = User(userDB['UserName'],
userDB['Id'],
active=True,
isAdmin=userDB['IsAdmin'],
securityStamp=userDB['SecurityStamp'],
isAuthenticated=True)
if user:
login_user(user)
return redirect(constants.loginRedirect)
else:
return redirect('/login')
else:
return redirect('/login')
else:
return redirect('/login')
else:
return redirect('/login')
def authorized():
if request.args.get('state') != session.get("state"):
return redirect(url_for("index")) # No-OP. Goes back to Index page
if "error" in request.args: # Authentication/Authorization failure
return render_template("auth_error.html", result=request.args)
if request.args.get('code'):
cache = _load_cache()
result = _build_msal_app(cache=cache).acquire_token_by_authorization_code(
request.args['code'],
scopes=config.SCOPE, # Misspelled scope would cause an HTTP 400 error here
redirect_uri=url_for("authorized", _external=True))
if "error" in result:
return render_template("auth_error.html", result=result)
session["user"] = result.get("id_token_claims")
_save_cache(cache)
users_email = session["user"]["preferred_username"]
users_name = ' '.join(session["user"]["name"].split(' ')[0:2])
user = User(
fullname=users_name, email=users_email, login_way='msft'
)
# Doesn't exist? Add it to the database.
user_from_db = db.session.query(User).filter(User.fullname == users_name).first()
if not user_from_db:
db.session.add(user)
db.session.commit()
user_from_db = db.session.query(User).filter(User.fullname == users_name).first()
logger.info(f"New user login via MSFT attempt: {session['user']['name']}")
elif user_from_db.login_way == 'msft':
logger.debug(f"User login via MSFT attempt: {session['user']['name']}")
else:
logger.debug(f"User login via MSFT attempt: {session['user']['name']}. This is it's first login via MSFT")
login_user(user_from_db, remember=True)
return redirect(request.args.get('next') or url_for("index"))
def create(self):
name_file = "/Users/yveslym/Desktop/portfolio/MOB2/trip-planner/name.txt"
domain_file = "/Users/yveslym/Desktop/portfolio/MOB2/trip-planner/domain.txt"
country_file = "/Users/yveslym/Desktop/portfolio/MOB2/trip-planner/country.txt"
open_country_file = open(country_file).read().split()
open_name_file = open(name_file).read().split()
open_domain_file = open(domain_file).read().split()
country = open_country_file[random.randint(0,len(open_country_file)-1)]
fname = open_name_file[random.randint(0, len(open_name_file) - 1)]
lname = open_name_file[random.randint(0, len(open_name_file) - 1)]
domain_name = open_domain_file[random.randint(0, len(open_domain_file) - 1)]
uname = fname + lname
mail = fname + '.' + lname + '@' + domain_name
user = User()
user.first_name = fname
user.last_name = lname
user.email = mail
user.country = country
user.password = '******'
user.username = uname
return(user)
def create_admin():
"""Creates the administrative user."""
db.create_all()
new_role = get_or_create(db.session,
Role,
name="admin",
description="Administrative user.")
new_role1 = get_or_create(
db.session,
Role,
name="client",
description=
"Client user(user who signed up using oauth or email + password).")
db.session.commit()
try:
new_user = User(email="*****@*****.**",
password="******",
first_name="administrative",
last_name="user",
active=True,
created=datetime.datetime.now(),
roles=[
new_role,
],
social_id=None)
# new_user.roles.append(new_role)
db.session.commit()
except exc.IntegrityError:
db.session().rollback()
def setup():
app.config['LOGIN_DISABLED'] = True
__create_db()
hashed_password = bcrypt.hashpw(password.encode(), bcrypt.gensalt())
user = User(name=name, hashed_password=hashed_password, client_id=os.getenv('CLIENT_ID'), client_secret=os.getenv('CLIENT_SECRET'))
db.session.add(user)
db.session.commit()
def createUser():
print('creating user')
username = request.json.get('username')
firstname = request.json.get('firstname')
lastname = request.json.get('lastname')
email = request.json.get('email')
password = request.json.get('password')
if username is None or password is None:
abort(400) # missing arguments
if User.query.filter_by(username=username).first() is not None:
abort(400) # existing user
user = User(username=username,
firstname=firstname,
lastname=lastname,
email=email)
user.hash_password(password)
rolesJSON = request.json.get('roles')
for role in rolesJSON:
roleObj = Role.query.filter(Role.id == role['id']).first()
user.roles.append(roleObj)
db.session.add(user)
db.session.commit()
return jsonify({'operation': 'success'})
