def sample_db():
admin = User("admin",
bcrypt.generate_password_hash("admin").decode('utf-8'))
db.session().add(admin)
monkey = User("SunWukong",
bcrypt.generate_password_hash("xiyouji").decode('utf-8'))
db.session().add(monkey)
generic_user = User("generic_user",
bcrypt.generate_password_hash("salis").decode('utf-8'))
db.session().add(generic_user)
db.session().commit()
role1 = Role("admin")
db.session().add(role1)
role2 = Role("user")
db.session().add(role2)
db.session().commit()
urole1 = UserRole(1, 1)
db.session().add(urole1)
urole2 = UserRole(2, 2)
db.session().add(urole2)
urole3 = UserRole(3, 2)
db.session().add(urole3)
db.session().commit()
alueet = ["Yleinen", "Bysanttilainen dädä", "Sekalainen"]
for i in range(len(alueet)):
alue = Category(alueet[i])
db.session().add(alue)
db.session().commit()
return
def add_admin(user):
if db.session.query(Role.id).filter_by(user_id=user.id,
name="ADMIN").scalar() is None:
role = Role()
role.name = "ADMIN"
role.user_id = user.id
db.session().add(role)
db.session.commit()
def init_db():
""" Pop DB with initial data
"""
import json
# init db:
db.drop_all()
db.create_all()
# init roles:
Role.init_roles()
# load accounts:
with open('data/accounts.json') as accounts_json_file:
accounts = json.load(accounts_json_file)
# add users:
success = False
try:
for user in accounts["users"]:
# init user:
user = User(**user)
# set role:
if user.username.startswith('barista'):
user.role_id = Role.query.filter(Role.name == 'barista').first().id
elif user.username.startswith('manager'):
user.role_id = Role.query.filter(Role.name == 'manager').first().id
# add to transaction:
db.session.add(user)
db.session.commit()
success = True
except:
db.session.rollback()
success=False
finally:
db.session.close()
# add posts:
success = False
while Post.query.count() < 120:
# in case the Faker creates a duplicated post:
try:
# init post:
post = PostFactory()
# TODO: implement random author assignment:
post.author_id = 1
db.session.add(post)
db.session.commit()
except:
db.session.rollback()
db.session.close()
def users_create():
if request.method == "GET":
return render_template("auth/userform.html", form=UserForm())
form = UserForm(request.form)
if not form.validate():
flash("Please, check your input!", category="warning")
return render_template("auth/userform.html", form=form)
if not form.password.data == form.password_conf.data:
flash("Passwords not equal!", category="warning")
return render_template("auth/userform.html", form=form)
try:
name = form.name.data
username = form.username.data
password = form.password.data
r = form.role.data
u = User(name, username, password)
u.roles.append(Role(name=r))
db.session().add(u)
db.session().commit()
flash("New user account created successfully!", category="success")
return redirect(url_for("index"))
except IntegrityError:
flash("Username already taken!", category="warning")
return render_template("auth/userform.html", form=form)
def auth_register():
form = RegistrationForm(request.form)
if request.method == "GET":
return render_template("auth/registrationform.html", form=form)
if not form.validate():
flash(form.errors)
flash(form.validate())
return render_template("auth/registrationform.html", form=form)
user = User.query.filter_by(username=form.username.data).first()
if user:
return render_template("auth/registrationform.html",
form=form,
error="User exists")
username = form.username.data
email = form.email.data
password = form.password.data
user = User(username, email, password)
db.session().add(user)
db.session().commit()
db.session().add(Role(user.id, "USER"))
db.session().commit()
login_user(user)
return redirect(url_for("index"))
def test_create_user(self):
with self.app.app_context():
test_role = Role(name="regular", type_='consumer', is_admin=False)
self.db.session.add(test_role)
self.db.session.commit()
test_user = User(
username='******',
social_id=None,
password=PasswordUtilities.generate_password('TestUser123!'),
first_name='test',
last_name='user',
date_of_birth=datetime(1991, 10, 10).date(),
role=test_role.pk)
self.db.session.add(test_user)
self.db.session.commit()
users = User.query.all()
self.assertEqual(len(users), 1)
self.assertEqual(users[0].username, 'test_user')
self.assertEqual(users[0].social_id, None)
self.assertTrue(
PasswordUtilities.authenticate(test_user, 'TestUser123!'))
self.assertEqual(users[0].first_name, 'test')
self.assertEqual(users[0].last_name, 'user')
self.assertEqual(users[0].date_of_birth,
datetime(1991, 10, 10).date())
self.assertEqual(users[0].role, test_role.pk)
self.assertEqual(users[0].Role, test_role)
def create_roles(self):
with self.app.app_context():
self.roles = {}
for role in ROLES:
self.roles[role["name"]] = Role(**role)
self.db.session.add(self.roles[role["name"]])
self.db.session.commit()
def user_create_as_admin():
form = NewUserForm(request.form)
if not form.validate():
return render_template("auth/new.html", form = form)
user = User.query.filter_by(username=form.username.data).first()
if user is not None:
return render_template("auth/new.html", form = form,
error = "Käyttäjänimi on jo varattu")
u = User(form.name.data, form.username.data, form.password.data, form.email.data, form.phone.data)
db.session().add(u)
db.session().commit()
role = Role.query.filter_by(name="user").first()
user = User.query.filter_by(username=u.username).first()
if role is None:
db.session.add(Role("user"))
db.session.commit()
role = Role.query.filter_by(name="user").first()
if form.admin.data == True:
role = Role.query.filter_by(name="admin").first()
user_role = UserRole(user.id, role.id)
db.session.add(user_role)
db.session.commit()
return redirect(url_for("list_users"))
def test_create_role(self):
with self.app.app_context():
test_role = Role(name="admin", type_='admin', is_admin=True)
self.db.session.add(test_role)
self.db.session.commit()
roles = Role.query.all()
self.assertEquals(len(roles), 1)
self.assertEquals(roles[0].name, 'admin')
self.assertEqual(roles[0].type_, 'admin')
self.assertEqual(roles[0].is_admin, True)
def create_user():
if User.query.count() == 0:
Event.query.delete()
Venue.query.delete()
User.query.delete()
Role.query.delete()
db.session.commit()
r = Role(name="admin", description="Administrator")
db.session.add(r)
u = User(
username="******",
full_name="Administrator",
password="******",
email="admin@localhost",
)
u.roles.append(r)
db.session.add(u)
u2 = User(
username="******",
full_name="Basic User",
password="******",
email="basic@localhost",
)
db.session.add(u2)
v1 = Venue(name="Gurula", location="Exactum")
db.session.add(v1)
v2 = Venue(name="Klusteri", location="Leppäsuonkatu 12, Helsinki")
db.session.add(v2)
db.session.commit()
e = Event(
admin_id=u.id,
name="Testitapahtuma",
info="Testi",
venue_id=v1.id,
start_time=datetime.now() + timedelta(hours=2),
end_time=datetime.now() + timedelta(hours=4),
)
db.session().add(e)
e = Event(
admin_id=u.id,
name="Testitapahtuma2",
info="Testi2",
venue_id=v2.id,
start_time=datetime.now() + timedelta(hours=2),
end_time=datetime.now() + timedelta(hours=4),
)
db.session().add(e)
db.session.commit()
return redirect(url_for("index"))
def user_edit():
id = request.args.get("user_id")
user = User.query.get(id)
form = UserForm(obj=user)
if request.method == 'POST' and form.validate():
role = Role.query.filter_by(name=form.role.data).first()
if not role:
role = Role(form.role.data)
db.session().add(role)
user.roles.clear()
user.roles.append(role)
form.populate_obj(user)
db.session().commit()
return redirect(url_for("books_index"))
return render_template('auth/edit.html', form=form)
def users_create():
form = UserForm(request.form)
if not form.validate():
return render_template("auth/userform.html", form=form)
u = User(form.name.data, form.e_mail.data, form.address.data,
form.username.data, form.password.data)
role = Role.query.filter_by(name=form.role.data).first()
if not role:
role = Role(form.role.data)
db.session().add(role)
u.roles.append(role)
db.session().add(u)
db.session().commit()
return redirect(url_for("books_index"))
def auth_update(user_id):
user = User.query.get(user_id)
form = EditForm(request.form)
form.role.choices = [('USER', 'Regular'), ('ADMIN', 'Adminstrator')]
if not form.validate():
return render_template("auth/edit_user.html", user=user, form=form)
user.email = form.email.data
rolename = form.role.data
#just overwrite existing role instead of utilizing the table structure
#for simplified management
role = Role.query.filter_by(account_id=user_id).first()
if role is not None:
if (role.name is not rolename):
role.name = rolename
else:
role = Role(user_id, rolename)
db.session.add(role)
db.session().commit()
return redirect(url_for("administrate_access"))
def insert_role_data():
roles = [{
'name': 'regular',
'type_': 'consumer',
'is_admin': False
}, {
'name': 'corporate',
'type_': 'business',
'is_admin': False
}, {
'name': 'admin',
'type_': 'admin',
'is_admin': True
}]
if len(Role.query.all()) > 0:
return
for role in roles:
new_role = Role(**role)
db.session.add(new_role)
db.session.commit()
def create_user():
if current_user.is_authenticated:
return redirect(url_for("index"))
form = SignupForm(request.form)
if not form.validate():
form.password.data = ""
form.repeat.data = ""
return render_template("auth/signup.html", form=form)
name = request.form.get('name')
username = request.form.get('username')
password = request.form.get('password')
user = User(name, username, password)
userRole = Role.find_role_by_name("USER")
role = Role.query.get(userRole[0]["id"])
user.roles.append(role)
print("\n\n\n")
print(user.roles)
print("\n\n\n")
db.session().add(user)
db.session().commit()
return redirect(url_for("auth_login"))
# ingredients
from application.ingredient import models
from application.ingredient import views
# user recipes
from application.user_recipe import models
# recipe ingredients
from application.recipe_ingredient import models
# log in
from application.auth.models import User
from application.auth.models import Role
try:
roles = Role.query.all()
if len(roles) < 1:
admin = Role(name="ADMIN")
user = Role(name="USER")
db.session().add(admin)
db.session().add(user)
db.session().commit()
print("\n Roles added to table 'Roles' \n")
except:
print("\n Could not add role to table 'Roles' \n")
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
# creates tables to fb if necessary
from flask_login import LoginManager
from flask_user import UserManager
user_manager = UserManager(app, db, User)
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth_login"
login_manager.login_message = "Please login to use this functionality."
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
# luodaan taulut tarvittaessa
try:
db.create_all()
except:
pass
# luodaan admin käyttäjä tarvittaessa
if not User.query.filter(User.username == 'admin').first():
user = User(name='Administrator',
username='******',
password=app.config["ADMIN_PASSWORD"])
user.roles.append(Role(name='admin'))
db.session.add(user)
db.session().commit()
return str(number) + " " + plural
app.jinja_env.filters['pluralize'] = pluralize
# Create database tables, if needed
try:
db.create_all()
except:
pass
# Create roles, if needed
roles = ["USER", "MODERATOR", "ADMIN"]
for role in roles:
role_exists = Role.query.filter_by(name=role).first()
if not role_exists:
db_role = Role(name=role)
db.session.add(db_role)
db.session.commit()
# Create demo user
exists = User.query.filter_by(name="demo").first()
if not exists:
demo = User(name="demo", password="******")
db.session.add(demo)
db.session.commit()
# Create demo admin
admin_exists = User.query.filter_by(name="admin").first()
if not admin_exists:
admin = User(name="admin", password="******")
from application.events import models
from application.events import views
from application.auth import models
from application.auth import views
from application.assignments import models
from application.assignments import views
try:
db.create_all()
from application.auth.models import Role
role = Role.query.filter_by(name="admin").first()
if not role:
db.session.add(Role("admin"))
db.session().commit()
role = Role.query.filter_by(name="user").first()
if not role:
role = Role("admin")
db.session.add(Role("user"))
db.session().commit()
except:
pass
def insert_initial_roles(*args, **kwargs):
db.session.add(Role("TEACHER", True))
db.session.add(Role("STUDENT", False))
db.session.commit()
from application.auth.models import User, Role
# database table creation
try:
db.create_all()
except:
pass
try:
from application.auth.models import Role
role = Role.query.filter_by(name='USER').first()
if not role:
role = Role('USER')
db.session().add(role)
db.session().commit()
role = Role.query.filter_by(name='FRISEUR').first()
if not role:
role = Role('FRISEUR')
db.session().add(role)
db.session().commit()
role = Role.query.filter_by(name='ADMIN').first()
if not role:
role = Role('ADMIN')
db.session().add(role)
if unauthorized:
return login_manager.unauthorized()
return fn(*args, **kwargs)
return decorated_view
return wrapper
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
try:
db.create_all()
adminrole = Role("ADMIN")
editor = Role("EDITOR")
lang = Role("LANGUAGE_CONSULTANT")
pic = Role("PICTURE_EDITOR")
layout = Role("LAYOUT_ARTIST")
admin_pw = os.environ.get("ADMIN_PW")
if not admin_pw:
raise Exception("ADMIN_PW is not set")
admin = User(username="******", name="Admin Admin", plaintext_password=admin_pw)
db.session.add(admin)
db.session.add_all((adminrole, editor, lang, pic, layout))
db.session.commit()
admin_is_admin = UserRole(user_id = admin.id, role_id = adminrole.id)
admin_is_editor = UserRole(user_id = admin.id, role_id = editor.id)
admin_is_lang = UserRole(user_id = admin.id, role_id = lang.id)
admin_is_pic = UserRole(user_id = admin.id, role_id = pic.id)
def insert_initial_values(*args, **kwargs):
db.session.add(Role(name="admin"))
db.session.add(Role(name="user"))
db.session.commit()
from application.questions import views
from application.auth import models
from application.auth import views
from application.teams import models
from application.teams import views
from application.auth.models import User
from application.auth.models import Role
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
try:
db.create_all()
except:
pass
#Initiate role table
admin_role = Role.query.filter_by(role="ADMIN").first()
if not admin_role:
Role.query.delete()
admin_role = Role("ADMIN")
other_role = Role("ANY")
db.session().add(admin_role)
db.session().add(other_role)
db.session().commit()
from application import views
from application.creatures import models
from application.auth.models import User, Role
from application.auth import views
from application.abilities.models import DamageType
from application.abilities import views
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
try:
db.create_all()
Role.initialize_roles()
User.initialize_admin()
DamageType.initialize_damagetypes()
except:
pass
damagetypes = []
types = DamageType.query.order_by(DamageType.type).all()
for dtype in types:
choice = (dtype.id, dtype.type)
damagetypes.append(choice)
from application.creatures import views
from application.auth.forms import LoginForm, UserEditForm
def insert_initial_roles(*args, **kwargs):
db.session.add(Role("ADMIN", True))
db.session.add(Role("USER", False))
db.session.commit()
def load_user(user_id):
return User.query.get(user_id)
try:
db.create_all()
from application.auth.models import Role
from application.tour.models import Tour
from datetime import datetime
role = Role.query.filter_by(name='USER').first()
if not role:
role = Role('USER')
db.session().add(role)
db.session().commit()
role = Role.query.filter_by(name='ADMIN').first()
if not role:
role = Role('ADMIN')
db.session().add(role)
db.session().commit()
admin = User.query.filter_by(role_id=2).first()
if not admin:
admin = User("ADMIN","admin","admin")
from application.categories.models import Category
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
# datetime custom filter
def format_datetime(value, format='%d-%m-%Y %H:%M:%S'):
return value.strftime(format)
app.jinja_env.filters['datetime'] = format_datetime
# initiliaze database with default category and admin role
try:
db.create_all()
if not Role.query.first():
admin_role = Role("admin")
db.session.add(admin_role)
db.session.commit()
if not Category.query.first():
default_category = Category('default')
db.session.add(default_category)
db.session.commit()
except:
pass
'aukusti@asianajotoimisto', 'Aukusti', 'Asiakas',
'pbkdf2:sha256:50000$OAKvqFOV$3d70a08136ace0d5f2ffc8f0e4763005d0954162906baaba62ed3edc902b0ef1',
2, True))
db.session.add(
User(
'akuliina@asianajotoimisto', 'Akuliina', 'Asiakas',
'pbkdf2:sha256:50000$OAKvqFOV$3d70a08136ace0d5f2ffc8f0e4763005d0954162906baaba62ed3edc902b0ef1',
2, True))
db.session.add(
User(
'ida@ideahautomo', 'Ida', 'Asiakas',
'pbkdf2:sha256:50000$OAKvqFOV$3d70a08136ace0d5f2ffc8f0e4763005d0954162906baaba62ed3edc902b0ef1',
3, True))
db.session.commit()
db.session.add(Role('Pääylläpitäjä'))
db.session.add(Role('Ylläpitäjä'))
db.session.add(Role('Asiakas'))
db.session.commit()
db.session.add(UserRole(1, 1)) # Administrator-paivio
db.session.add(UserRole(2, 1)) # Editor-paivio
db.session.add(UserRole(2, 2)) # Editor-yngve
db.session.add(UserRole(3, 3)) # Customer-aukusti
db.session.add(UserRole(3, 4)) # Customer-akuliina
db.session.add(UserRole(3, 5)) # Customer-ida
db.session.commit()
import datetime
#Analysis: def __init__(self, company_id, name, keywords, locked, date_crawled):
db.session.add(
from flask_login import LoginManager
login_manager = LoginManager()
login_manager.init_app(app)
login_manager.login_view = "auth_login"
login_manager.login_message = "Please, login to use this functionality."
@login_manager.user_loader
def load_user(user_id):
return User.query.get(user_id)
from flask_user import UserManager, SQLAlchemyAdapter
db_adapter = SQLAlchemyAdapter(db, User)
user_manager = UserManager(db_adapter, app)
db.create_all()
if not User.query.filter_by(username='******').first():
name = 'Aku Ankka'
username = '******'
pwd = 'akuankka'
user1 = User(name, username, pwd)
user1.roles.append(Role(name='ADMIN'))
db.session().add(user1)
db.session().commit()
