def setUpClass(cls):
# 启动Firefox
try:
cls.client = webdriver.Firefox()
except:
pass
# 如果无法启动浏览器，则跳过这些测试
if cls.client:
# 创建程序
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# 禁止日志，保持输出简洁
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
# 创建数据库
db.create_all()
Role.insert_role()
# 添加管理员
admin_role = Role.query.filter_by(permission=0xff).first()
admin = User(email='*****@*****.**',
username='******', pasword='cat',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# 在一个线程中启动Flask服务器
threading.Thread(target=cls.app.run).start()
def setUp(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
self.client = self.app.test_client()
def setUpClass(cls):
try:
cls.client = webdriver.Firefox()
except:
pass
if cls.client:
cls.app = create_app('testing')
cls.app_context = cls.app_context()
cls.app_context.push()
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
threading.Thread(target=cls.app.run).start()
time.sleep(1)
def setUp(self):
self.app = create_app("testing")
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
self.client = self.app.test_client(use_cookies=True)
def setUpClass(cls):
try:
cls.client = webdriver.Firefox()
except:
pass
if cls.client:
# create app
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# create log
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel(logging.ERROR)
# create database
db.create_all()
Role.init_roles()
User.generate_fake(count=10)
Post.generate_fake(count=10)
# add admin
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**', username='******',
password='******', role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# run server in child thread
Thread(target=cls.app.run).start()
def createdb():
print 'creating db..'
db.drop_all()
db.create_all()
Role.insert_roles()
print 'adding feed sources..'
with open('sources.yaml', 'r') as f:
feed_sources = yaml.load(f)
# Insert feedprovider
for site in feed_sources:
provider_name = unicode(site['name'])
provider_domain = site['domain']
provider = FeedProvider(name = provider_name,
domain = provider_domain,
favicon = site['favicon'])
db.session.add(provider)
db.session.commit()
# Add feedsource
for channel_name in site['channels']:
source_name = unicode(site['name'] + ' - ' + channel_name)
source_href = site['channels'][channel_name]
fs = FeedSource(name=source_name, url=source_href, provider=provider)
db.session.add(fs)
db.session.commit()
print 'add feed articles..'
from app.mod_crawler.fetch import update_db
update_db()
def setUp(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
self.client = self.app.test_client(use_cookies=True) #测试客户端对象 （启用cookie像浏览器一样可能接收和发半发送cookie）
def deploy():
from flask_migrate import upgrade
from app.models import Role, User
upgrade()
Role.insert_roles()
User.add_self_follows()
def setUpClass(cls):
#launch Firefox
try:
cls.client = webdriver.Chrome()
except:
pass
if cls.client:
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel('ERROR')
# create database, and fill it up with some faked data
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
# add administrater
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# launch Flask server in a thread
threading.Thread(target=cls.app.run).start()
# give the server a second to ensure it is up
time.sleep(1)
def deploy(): from flask.ext.migrate import upgrade from app.models import Role,User upgrade() Role.insert_roles()
def recreate_data():
"""Generate fake data for development and testing"""
print 'dropping existing tables...'
db.drop_all()
print 'creating tables...'
db.create_all()
print 'inserting roles...'
Role.insert_roles()
print 'creating admin user...'
u1 = User(username='******', email='*****@*****.**', password='******',
name='Ralph Wen', location='Hangzhou, China',
about_me='This is the creator of everything', confirmed=True)
db.session.add(u1)
print 'creating moderate user...'
u2 = User(username='******', email='*****@*****.**', password='******',
name='Yadong Wen', location='Hangzhou, China',
about_me='Yeah', confirmed=True)
db.session.add(u2)
db.session.commit()
print 'generating 50 normal users...'
User.generate_fake(50)
print 'generating 500 posts...'
Post.generate_fake(500)
print 'generating follows...'
User.generate_following()
print 'generating comments...'
Comment.generate_comments()
print '...done'
def roleDelete(request):
"""
delete the role
"""
if request.method=="POST":
myDict = dict(request.POST.iterlists())
if(not myDict.get('deleteRole')):
return
roleID=myDict['deleteRole'][0]
mR=Role.objects.get(id=roleID)
if(mR.name=='默认权限'):
mR.editCalendar=False
mR.editMeeting=False
mR.editStaff=False
mR.editTask=False
mR.exportFile=False
mR.level=5
mR.save()
messages.success(request, '删除成功')
return
if(Role.objects.filter(name='默认权限').count()==1):
minR=Role.objects.get(name='默认权限')
else:
minR=Role(name='默认权限',level=5,editStaff=False,editTask=False,editCalendar=False,editMeeting=False,exportFile=False)
minR.save()
for item in mR.staff.all():
item.role=minR
item.save()
mR.delete()
cache.clear()
messages.success(request, '删除成功')
def deploy():
"""Run development tasks."""
from flask.ext.migrate import upgrade
from app.models import Role, User
upgrade()
Role.insert_roles()
User.add_self_follows()
def forged():
from forgery_py import basic, lorem_ipsum, name, internet, date
from random import randint
db.drop_all()
db.create_all()
Role.seed()
guests = Role.query.first()
def generate_comment(func_author, func_post):
return Comment(body=lorem_ipsum.paragraphs(),
created=date.date(past=True),
author=func_author(),
post=func_post())
def generate_post(func_author):
return Post(title=lorem_ipsum.title(),
body=lorem_ipsum.paragraphs(),
created=date.date(),
author=func_author())
def generate_user():
return User(name=internet.user_name(),
email=internet.email_address(),
password=basic.text(6, at_least=6, spaces=False),
role=guests)
users = [generate_user() for i in range(0, 5)]
db.session.add_all(users)
random_user = lambda: users[randint(0, 4)]
posts = [generate_post(random_user) for i in range(0, randint(50, 200))]
db.session.add_all(posts)
random_post = lambda: posts[randint(0, len(posts) - 1)]
comments = [generate_comment(random_user, random_post) for i in range(0, randint(2, 100))]
db.session.add_all(comments)
db.session.commit()
def deploy():
"""运行部署任务"""
from flask.ext.migrate import upgrade
upgrade()
Role.insert_roles()
City.insert_cities()
Topic.insert_topics()
def deploy(): """迁移数据库并创建用户角色""" from flask.ext.migrate import upgrade from app.models import Role, User upgrade() Role.insert_roles()
def test_orm_create_role(app):
role = Role(role_dict)
role.validate()
role.save()
assert isinstance(role, Role)
assert role.name == role_dict['name']
assert role.description == role_dict['description']
def migrate_meta():
from app.models import User, Role, Permission, \
IUCNStatus, ESAStatus, OrganismType, GrowthFormRaunkiaer, ReproductiveRepetition, \
DicotMonoc, AngioGymno, SpandExGrowthType, SourceType, Database, Purpose, MissingData, ContentEmail, Ecoregion, Continent, InvasiveStatusStudy, InvasiveStatusElsewhere, StageTypeClass, \
TransitionType, MatrixComposition, StartSeason, StudiedSex, Captivity, Species, Taxonomy, Trait, \
Publication, Study, AuthorContact, AdditionalSource, Population, Stage, StageType, Treatment, \
MatrixStage, MatrixValue, Matrix, Interval, Fixed, Small, CensusTiming, PurposeEndangered, PurposeWeed, Institute
print "Migrating Meta Tables..."
try:
Role.insert_roles()
Species.migrate()
Taxonomy.migrate()
Trait.migrate()
Publication.migrate()
AuthorContact.migrate()
Population.migrate()
StageType.migrate()
MatrixValue.migrate()
Matrix.migrate()
Fixed.migrate()
Study.migrate()
User.migrate()
Version.migrate()
Institute.migrate()
except:
"Error migrating metadata"
finally:
"Done + good"
return
def deploy(): """Run deployment tasks""" from flask.ext.migrate import upgrade from app.models import Role, User upgrade() Role.insert_roles()
def setUpClass(cls):
# start Firefox
try:
cls.client = webdriver.Firefox()
except:
pass
# skip these tests if the browser could not be started
if cls.client:
# create the application
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# suppress logging to keep unittest output clean
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
# create the database and populate with some fake data
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
# add an administrator user
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# start the Flask server in a thread
threading.Thread(target=cls.app.run).start()
def setUpClass(cls):
chromedriver_dir = os.path.abspath('./driver/chromedriver.exe')
cls.client = webdriver.Chrome(executable_path=chromedriver_dir)
if cls.client:
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******',
password='******',
role=admin_role,
confirmed=True)
db.session.add(admin)
db.session.commit()
threading.Thread(target=cls.app.run).start()
def test_roles_and_permissions(self):
Role.insert_roles()
u = User(email = '*****@*****.**', password='******')
self.assertFalse(u.can(Permission.WRITE_ARTICLES))
u2 = User(email = '*****@*****.**', password = '******', confirmed =True)
self.assertTrue(u2.can(Permission.WRITE_ARTICLES))
self.assertFalse(u2.can(Permission.MODERATE_COMMENTS))
def setUpClass(cls): # 在这个类中的全部测试运行前执行
# 启动 Chrome
try:
cls.client = webdriver.Chrome() # 在类方法中，通过 cls 参数调用类的方法、属性
except:
pass
# 如果无法启动浏览器,则跳过这些测试
if cls.client:
# 创建程序
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# 日志？？
import logging
logger = logging.getLogger('werkzeug') # 获取logger对象
logger.setLevel('ERROR') # 设置获取 ERROR 级别的日志
# 创建数据库，使用一些虚拟数据填充
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
# 添加管理员用户
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**', username='******', password='******', role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# 在线程中启动 Flask 服务器
threading.Thread(target=cls.app.run).start() # 启用程序
def rebuild():
if config == 'development':
with app.app_context():
db.drop_all()
db.create_all()
Role.insert_roles()
admin_me = User(email=app.config['FLASKR_ADMIN'],
username=app.config['MY_USERNAME'],
password=app.config['MY_PASSWORD'],
confirmed=True,
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentences(10),
member_since=forgery_py.date.date(True,
min_delta=10))
db.session.add(admin_me)
ordinary_me = User(email=forgery_py.internet.email_address(),
username='******',
password='******',
confirmed=True,
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentences(10),
member_since=forgery_py.date.date(True,
min_delta=10))
db.session.add(ordinary_me)
db.session.commit()
User.generate_fake(30)
Post.generate_fake(500)
Follow.generate_fake(500)
Comment.generate_fake(500)
else:
print('Permission denied.')
def createdb():
"""Create database tables"""
db_setup()
db.create_all()
# create user roles
Role.insert_roles()
def dts_init():
u"""数据库初始化"""
u"""首先执行数据库的初始化工作"""
db.create_all()
Role.insert_roles()
BugStatus.insert_bug_status()
print u"数据库初始化成功"
def test_administrator(self):
Role.insert_roles()
r = Role.query.filter_by(permissions=Permission.ADMINISTER).first()
u = User(email='*****@*****.**', password='******', role=r)
self.assertTrue(u.can(Permission.ADMINISTER))
self.assertTrue(u.can(Permission.GENERAL))
self.assertTrue(u.is_admin())
def setup(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_role()
self.client = self.app.test_client(use_cookie=True)
def test_make_administrator(self):
Role.insert_roles()
u = User(email='*****@*****.**', password='******')
self.assertFalse(u.can(Permission.ADMINISTER))
u.role = Role.query.filter_by(
permissions=Permission.ADMINISTER).first()
self.assertTrue(u.can(Permission.ADMINISTER))
def setUp(self):
super().setUp()
Role.insert_roles()
self.admin = User(role=Role.query.filter_by(name='Admin').first())
self.user = User()
self.any = AnonymousUser()
self.moderator = User(role=Role.query.filter_by(name='Moderator').first())
def post(self, org_id, location_id):
parser = reqparse.RequestParser()
parser.add_argument("name", type=str)
parser.add_argument("enable_timeclock", type=inputs.boolean)
parser.add_argument("enable_time_off_requests", type=inputs.boolean)
parser.add_argument("min_hours_per_workday", type=int, default=4)
parser.add_argument("max_hours_per_workday", type=int, default=8)
parser.add_argument("min_hours_between_shifts", type=int, default=12)
parser.add_argument("max_consecutive_workdays", type=int, default=6)
parameters = parser.parse_args(strict=True)
# Filter out null values
parameters = dict(
(k, v) for k, v in parameters.iteritems() if v is not None)
organization = Organization.query.get_or_404(org_id)
min_half_hours_per_workday = parameters.get(
"min_hours_per_workday") * 2
max_half_hours_per_workday = parameters.get(
"max_hours_per_workday") * 2
min_half_hours_between_shifts = parameters.get(
"min_hours_between_shifts") * 2
max_consecutive_workdays = parameters.get("max_consecutive_workdays")
if min_half_hours_per_workday > max_half_hours_per_workday:
return {
"message":
"min_hours_per_workday cannot be greater than max_hours_per_workday"
}, 400
if not (1 <= min_half_hours_per_workday <= 48):
return {
"message": "min_hours_per_workday must be between 1 and 24"
}, 400
if not (1 <= max_half_hours_per_workday <= 48):
return {
"message": "max_hours_per_workday must be between 1 and 24"
}, 400
if not (0 <= min_half_hours_between_shifts <= 48):
return {
"message": "min_hours_between_shifts must be between 0 and 24"
}, 400
if not (4 <= max_consecutive_workdays <= 13):
return {
"message": "max_consecutive_workdays must be between 4 and 13"
}, 400
enable_timeclock = parameters.get(
"enable_timeclock", organization.enable_timeclock_default)
enable_time_off_requests = parameters.get(
"enable_time_off_requests",
organization.enable_time_off_requests_default)
role = Role(
name=parameters.get("name"),
location_id=location_id,
enable_timeclock=enable_timeclock,
enable_time_off_requests=enable_time_off_requests,
min_half_hours_per_workday=min_half_hours_per_workday,
max_half_hours_per_workday=max_half_hours_per_workday,
min_half_hours_between_shifts=min_half_hours_between_shifts,
max_consecutive_workdays=max_consecutive_workdays,
)
db.session.add(role)
try:
db.session.commit()
g.current_user.track_event("created_org")
return marshal(role, role_fields), 201
except:
abort(500)
def setUp(self):
self.app = create_app('testing')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
def test_roles_and_permissions(self):
Role.insert_roles()
u = User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.WRITE_ARTICLES))
self.assertFalse(u.can(Permission.MODERATE_COMMENTS))
def test_roles_and_permissions(self):
Role.insert_roles()
u=User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.GENERAL))
self.assertFalse(u.can(Permission.ADMINISTER))
def deploy():
from flask_migrate import upgrade
from app.models import Role
upgrade()
Role.insert_roles()
def create_roles():
"""Add roles to db"""
for role in ['admin', 'student', 'teacher']:
r = Role(role=role)
db.session.add(r)
db.session.commit()
def deploy():
"""Run deployment tasks."""
upgrade()
Role.insert_roles()
def setUp(self):
'''
Set up method that will run before every Test
'''
self.user_role = Role(name="Banana Eater")
self.new_user = User(password='******', role=self.user_role)
def setUp(self):
'''在每个测试前运行, 初始化测试环境'''
db.create_all()
Role.insert_roles()
def init_role():
Role.insert_roles()
def db_rebuild():
"""
Destroy and rebuild database with fake data.
"""
# destroy and rebuild tables
db.reflect()
db.drop_all()
db.create_all()
# insert roles as defined in model
Role.insert_roles()
# insert geos and usertypes as defined in model
Geo.insert_geos()
UserType.insert_user_types()
# insert firm types/tiers as defined in model
FirmType.insert_firm_types()
FirmTier.insert_firm_tiers()
# insert fake admin/test users
from random import seed
import forgery_py
seed()
test_user_1 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Salim Hamed',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
test_user_2 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bryan Davis',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
test_user_3 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Joe Smith',
location='San Francisco, CA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
test_user_4 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bill Gates',
location='Bellevue, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
admin_user = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
name='Bill Gates',
location='Seattle, WA',
about_me=forgery_py.lorem_ipsum.sentence(),
member_since=forgery_py.date.date(True))
db.session.add_all(
[test_user_1, test_user_2, test_user_3, test_user_4, admin_user])
db.session.commit()
# insert fake user data
User.generate_fake(60)
# insert fake post data
Post.generate_fake(400)
# insert fake followers
Follow.generate_fake(2000)
# insert fake firms
Firm.generate_fake(5000)
# insert fake companies
Company.generate_fake(10000)
# insert fake relationships
Relationship.generate_fake(60000)
# print results
inspector = db.inspect(db.engine)
print 'The following tables were created.'
print '-' * 17
for table in inspector.get_table_names():
print table
def deploy():
from app.models import Role
upgrade()
Role.seed()
def setup_general():
"""Runs the set-up needed for both local development and production."""
Role.insert_roles()
EditableHTML.add_default_faq()
def test_create_role(app):
role = Role(role_dict)
role.save()
assert isinstance(role, Role)
assert role.name == role_dict['name']
assert role.description == role_dict['description']
def test_is_not_student(self):
u = User(email='*****@*****.**', password='******')
u.role = Role.get('Teacher')
self.assertFalse(u.is_student())
def create_role(role: str):
db.session.add(Role(name=role))
db.session.commit()
def test_is_teacher(self):
u = User(email='*****@*****.**', password='******')
u.role = Role.get('Teacher')
self.assertTrue(u.is_teacher())
def test_user_is_teacher_by_default(self):
u = User(email='*****@*****.**', password='******')
self.assertEquals(Role.get('Student'), u.role)
def deploy():
"""Run deployment tasks."""
upgrade()
Role.insert_roles()
User.add_self_follows()
def test_is_student(self):
u = User(email='*****@*****.**', password='******')
u.role = Role.get('Student')
self.assertTrue(u.is_student())
def test_roles_and_permissions(self):
Role.insert_roles()
u = User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.WRITE))
self.assertTrue(u.can(Permission.MODERATE))
def deploy():
"""运行部署任务"""
upgrade()
Role.insert_roles()
User.add_self_follows()
def test_role_permission(self):
Role.insert_roles()
u = User(username='******')
self.assertTrue(u.can(Permission.WRITE_ARTICLES))
self.assertFalse(u.can(Permission.MODERATE_COMMENTS))
def deploy():
from flask.ext.migrate import upgrade
from app.models import Role, User
upgrade()
Role.insert_roles()
User.add_self_follows()
def setUp(self):
self.new_role = Role(name="adm")
self.new_user = User(username="******",
email="*****@*****.**",
password="******",
role=self.new_role)
# -*- coding: utf-8 -*-
from app import app, db
from app.models import User, Book, Log, Role
app_ctx = app.app_context()
app_ctx.push()
db.create_all()
Role.insert_roles()
admin = User(name=u'root',
email='*****@*****.**',
password='******',
major='administrator',
headline=u"Administrator",
about_me=u"Bibliotecario.")
user1 = User(name=u'Marcelo',
email='*****@*****.**',
password='******',
major='Engenharia de Computação',
headline=u"Estudante")
#book1 = Book(title=u"Python", subtitle=u"Python Fluente: Programação Clara, Concisa e Eficaz ", author=u"Luciano Ramalho", isbn='9787115373991',
# tags_string=u"Computação, Programação, Engenharia", image='https://images-na.ssl-images-amazon.com/images/I/51Ov4P3XiEL._SX357_BO1,204,203,200_.jpg',
# summary=u'A simplicidade de Python permite que você se torne produtivo rapidamente, porém isso muitas vezes significa que você não estará usando tudo que ela tem a oferecer. Com este guia prático, você aprenderá a escrever um código Python eficiente e idiomático aproveitando seus melhores recursos – alguns deles, pouco conhecidos. O autor Luciano Ramalho apresenta os recursos essenciais da linguagem e bibliotecas de Python mostrando como você pode tornar o seu código mais conciso, mais rápido e mais legível ao mesmo tempo.'
#)
db.session.add_all([admin, user1])
db.session.commit()
app_ctx.pop()
def test_roles_and_permissions(self):
Role.insert_roles()
u = User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.WRITE_ARTICLES))
self.assertFalse(u.can(Permission.MODERATE_COMMENTS))
def rolemanagement(role):
if current_user.is_authenticated:
if current_user.check_permission('usercenter_role_edit'):
if role != None:
role = role.replace("%20", "+")
print(role)
if Role.query.filter(Role.rolename == role).count() == 1:
roletoedit = role
else:
flash("No legal role found")
return redirect(url_for('usercenter.list_role'))
else:
return redirect(url_for('usercenter.lobby'))
else:
flash('You are not allowed to change')
return redirect(url_for('usercenter.lobby'))
role = Role.query.filter(Role.rolename == roletoedit).first()
form = form_edit_role()
if form.validate_on_submit():
if form.old_rolename.data != form.rolename.data:
if Role.query.filter(
Role.rolename == form.old_rolename.data).count() == 1:
role.rolename = form.rolename.data
db.session.commit()
flash('Rolename has been changed to ' + form.rolename.data)
print(role.rolename)
return redirect(
url_for('usercenter.rolemanagement',
role=role.rolename))
if Role.query.filter(
Role.rolename == form.old_rolename.data).count() == 0:
newrole = Role(rolename=form.rolename.data)
db.session.add(newrole)
db.session.commit()
flash('Rolename ' + form.rolename.data +
' has been created ')
print(role.rolename)
else:
flash('Rolename already exists')
flash(roletoedit)
permissionlist = db.session.query(Permission).all()
form2 = form_edit_role_add_perm()
form2.permissiontoadd.choices = [(g.id, g.permissionname)
for g in Permission.query.all()]
if form2.validate_on_submit():
if db.session.query(Roletopermission).filter(
Roletopermission.permission_id ==
form2.permissiontoadd.data).filter(
Roletopermission.role_id == role.id).count() == 0:
permissionid = db.session.query(Permission).filter(
Permission.id == form2.permissiontoadd.data).first()
NewRoletopermission = Roletopermission(
role_id=role.id, permission_id=permissionid.id)
db.session.add(NewRoletopermission)
db.session.commit()
#choicelist = [(g.id, g.permissionname) for g in db.session.query(Permission).all()]
#print(choicelist)
# form2.permissiontoadd.choices=choicelist
return render_template('usercenter/edit_role.html',
title=_('Edit Role'),
form=form,
form2=form2,
role=role,
permissionlist=permissionlist)
#!/usr/bin/env python3
from app import app, db
from app.models import Role, Setting, DomainTemplate
admin_role = Role(name='Administrator', description='Administrator')
user_role = Role(name='User', description='User')
setting_1 = Setting(name='maintenance', value='False')
setting_2 = Setting(name='fullscreen_layout', value='True')
setting_3 = Setting(name='record_helper', value='True')
setting_4 = Setting(name='login_ldap_first', value='True')
setting_5 = Setting(name='default_record_table_size', value='15')
setting_6 = Setting(name='default_domain_table_size', value='10')
setting_7 = Setting(name='auto_ptr', value='False')
template_1 = DomainTemplate(name='basic_template_1',
description='Basic Template #1')
template_2 = DomainTemplate(name='basic_template_2',
description='Basic Template #2')
template_3 = DomainTemplate(name='basic_template_3',
description='Basic Template #3')
db.session.add(admin_role)
db.session.add(user_role)
db.session.add(setting_1)
db.session.add(setting_2)
db.session.add(setting_3)
db.session.add(setting_4)
db.session.add(setting_5)
def reset_db():
"""Reset the database."""
db.drop_all()
db.create_all()
Role.insert_roles()
setup_roles()
