def setUpClass(cls):
try:
cls.client = webdriver.Chrome('./chromedriver')
except Exception:
pass
if not cls.client:
return
cls.app = create_app('test')
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()
Category.insert_categories()
FakeUtil.generate_fake_users(10)
FakeUtil.generate_fake_articles(10)
admin_role = Role.query.filter_by(name='Administrator').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 post(self):
from models.user import UserHasRole, User
from models.role import Role
from app import db
try:
user_id = request.json.get('id')
if not User.check_user(self.app_id, user_id):
return '权限错误', 400
now_roles = request.json.get('role_ids')
old_roles = UserHasRole.get_role(user_id)
need_delete = list(set(old_roles) - set(now_roles))
need_add = list(set(now_roles) - set(old_roles))
for n in need_add:
if Role.check_role(self.app_id, n):
m = UserHasRole()
m.user_id = user_id
m.role_id = n
db.session.add(m)
for d in need_delete:
if Role.check_role(self.app_id, d):
m = UserHasRole.query.filter_by(user_id=user_id, role_id=d).first()
db.session.delete(m)
db.session.commit()
except Exception as e:
db.session.rollback()
def run(self, **kwargs):
from models.user import User
from models.course import Course
from models.role import Role
with open('settings/secrets.json', 'r') as secret_file:
secrets = json.load(secret_file).get("ADMIN", {})
print("Adding Admin")
admin = User(first_name=secrets.get("first_name", "Admin"),
last_name=secrets.get("last_name", "User"),
password=hash_password(secrets.get(
"password", "password")),
confirmed_at=datetime.datetime.now(),
active=True,
email=secrets.get("email", "*****@*****.**"))
db.session.add(admin)
db.session.flush()
db.session.add(Role(name='instructor', user_id=admin.id))
db.session.add(Role(name='admin', user_id=admin.id))
print("Adding default course")
default_course = Course(name="Default Course",
owner_id=admin.id,
service="native")
db.session.add(default_course)
db.session.flush()
db.session.add(
Role(name='instructor',
course_id=default_course.id,
user_id=admin.id))
db.session.commit()
print("Complete")
def doEdit(id):
ro = Role()
a = (request.form.get('name'), id)
ret = ro.edit(a)
if ret > 0:
return redirect('/role')
return "Failed"
def create():
ro = Role()
id = randint(0, 999999)
name = request.form.get("name")
if ro.add((id, name)) > 0:
return jsonify({"id": id, "name": name})
return "Failed"
def create_roles():
logger.info('create_roles')
roles_by_name = {}
for user in User.query.all():
regexp = r'{}test.(.[a-z]+).(.*)@{}.{}'.format(COMMAND_NAME, APP_NAME,
TLD)
user_type = re.match(regexp, user.email).group(1)
if user_type == "master":
for role_type in RoleType:
roles_by_name['{} {}'.format(user.email, role_type)] = Role(
type=role_type.value, user=user)
elif user_type != 'user':
roles_by_name['{} {}'.format(user.email,
user_type)] = Role(type=getattr(
RoleType, user_type).value,
user=user)
ApiHandler.save(*roles_by_name.values())
logger.info('created {} roles'.format(len(roles_by_name)))
return roles_by_name
def create():
ro = Role()
name = request.form.get('name')
id = randint(10000, 99999)
if ro.add((id, name)) > 0:
return jsonify({'id': id, 'name': name})
return 'Failed'
def post(self):
from models.role import Role
from app import db
a = Role()
a.app_id = self.app_id
a.name = request.json.get('name')
db.session.add(a)
db.session.commit()
def __init__(self, connection):
self.connection = connection
from models.user import User
from models.role import Role
from models.user_role import UserRole
self.user = User(connection)
self.role = Role(connection)
self.user_role = UserRole(connection)
def index():
if request.cookies.get("session"):
acc = Account()
v = acc.getAccountIdBySession(request.cookies.get('session'))
accid = v['id']
ro = Role()
u = ro.getRoleByAccountId(accid)
return render_template("authen/index.html", v=v, u=u)
return redirect("/authen/signin")
def test_roles(t_client, db):
role_1 = Role(status="active", role="ADMIN")
role_2 = Role(status="active", role="USER")
db.add(role_1)
db.commit()
db.add(role_2)
db.commit()
assert role_1.id == 1
assert role_2.id == 2
def setUp(self):
self.app = create_app('test')
self.app_context = self.app.app_context()
self.app_context.push()
self.client = self.app.test_client(use_cookies=True)
db.create_all()
Role.insert_roles()
Category.insert_categories()
def role2(id):
acc = Account()
x = acc.getAccountsById(id)
# Thieu
ro = Role()
# Dictionary
b = ro.getRolesByAccount(id)
# print('--------', b)
return render_template('account/role2.html', a = x, arr = b)
def deploy():
"""部署"""
from flask_migrate import upgrade
# 迁移数据库到最新版本
upgrade()
Role.insert_roles()
Category.insert_categories()
def run(self, **kwargs):
from models.user import User
from models.course import Course
from models.role import Role
from models.assignment_group import AssignmentGroup
from models.assignment_group_membership import AssignmentGroupMembership
from models.assignment import Assignment
default_course = Course.query.first()
print("Adding Teacher")
teacher = User(first_name="Klaus",
last_name="Bart",
password=hash_password("password"),
confirmed_at=datetime.datetime.now(),
active=True,
email="*****@*****.**")
db.session.add(teacher)
db.session.flush()
db.session.add(
Role(name='instructor',
course_id=default_course.id,
user_id=teacher.id))
print("Adding Student")
student = User(first_name="Ada",
last_name="Bart",
password=hash_password("password"),
confirmed_at=datetime.datetime.now(),
active=True,
email="*****@*****.**")
db.session.add(student)
db.session.flush()
db.session.add(
Role(name='student',
course_id=default_course.id,
user_id=student.id))
print("Adding basic assignments")
basic_group = AssignmentGroup(name="First Group",
course_id=default_course.id,
owner_id=teacher.id)
db.session.add(basic_group)
db.session.flush()
for i in range(5):
assignment = Assignment(name="Problem {}".format(i),
instructions="Complete this problem",
owner_id=teacher.id,
course_id=default_course.id)
db.session.add(assignment)
db.session.flush()
db.session.add(
AssignmentGroupMembership(assignment_group_id=basic_group.id,
assignment_id=assignment.id))
db.session.commit()
print("Complete")
def __init__(self, connection):
self.connection = connection
from models.role import Role
from models.user_role import UserRole
self.role = Role(connection)
self.user_role = UserRole(connection)
from token_controller import TokenController
self.token_controller = TokenController(connection)
from user_role_controller import UserRoleController
self.user_role_controller = UserRoleController(connection)
def test_modife(app_r, role):
role_new = Role(id=role.id, name="QA_modife", type="Oksana_modife", level=8, book=2)
response = app_r.modife_object(role_new)
# Verification
assert response.status_code == 200
assert response.json() == role_new.get_dict_with_id()
response = app_r.get_object(role).json()
# Verification
assert response["level"] == 8
assert response["book"] == 2
def remove_role(role_id):
''' Endpoint to bounce a student from the course '''
role = Role.by_id(int(role_id))
if role is None:
return "Role not found"
course_id = role.course_id
is_instructor = g.user.is_instructor(course_id)
if not is_instructor:
return "You're not an instructor in this course!"
Role.remove(int(role_id))
return redirect(url_for('courses.manage_users', course_id=course_id))
def role(id):
acc = Account()
ro = Role()
air = AccountInRole()
b = air.getRoleByAccount(id)
li = []
for v in b:
li.append(v[0])
return render_template('account/role.html',
a=acc.getAccountById(id),
arr=ro.getRoles(),
brr=li)
def post_role():
check_has_role(current_user, 'admin')
user = load_or_404(User, request.json['userId'])
role = Role()
role.type = request.json['type']
role.user = user
ApiHandler.save(role)
return jsonify(as_dict(role)), 200
def post(self):
body = request.get_json()
role = Role(body["name"])
try:
role.save()
except Exception as e:
return (
{
"msg": "Something went wrong while adding new role.",
"description": e,
},
500,
)
return {"msg": "New role added", "new_role": role.json()}, 201
def test_create_role_no_level_and_book(app_r):
role = Role(name="QA", type="Oksana")
response = app_r.create_object(role)
# Verification
assert response.status_code == 201
assert role.get_level() is None
assert role.get_book() is None
response = app_r.get_object(role).json()
# Verification
assert response["level"] == 0
assert response["book"] is None
app_r.delete_object(role)
def role(id):
acc = Account()
x = acc.getAccountsById(id)
# Thieu
ro = Role()
air = AccountInRole()
# Transfer
# List
a = air.getRolesByAccount(id)
li = []
for v in a:
li.append(v[0])
# Diction
return render_template('account/role.html', a = x, arr = ro.getRoles(), brr = li)
def run(self):
roles = Role.find_all_by()
self.stdout.write('Roles in System:')
self.stdout.write("NAME\t\t\tDESCRIPTION")
self.stdout.write("-------------\t\t-------------")
for role in roles:
self.stdout.write("{name}\t\t{desc}".format(name=role.name, desc=role.description))
async def set_player_role(sid: str, data: PlayerRoleChange):
pr: PlayerRoom = game_state.get(sid)
if pr.role != Role.DM:
logger.warning(
f"{pr.player.name} attempted to change the role of a player")
return
new_role = Role(data["role"])
player_pr: PlayerRoom = PlayerRoom.get(player=data["player"], room=pr.room)
creator: User = player_pr.room.creator
if pr.player != creator and creator == player_pr.player:
logger.warning(
f"{pr.player.name} attempted to change the role of the campaign creator"
)
return
player_pr.role = new_role
player_pr.save()
for sid in game_state.get_sids(player=player_pr.player, room=pr.room):
await sio.disconnect(sid, namespace=GAME_NS)
for psid in game_state.get_sids(room=pr.room):
if game_state.get(psid).role == Role.DM:
await sio.emit("Player.Role.Set",
data,
room=psid,
namespace=GAME_NS)
def get_role(id):
sql = "Select * from roles where id = %s"
cursor = connection.cursor()
cursor.execute(sql, [id])
record = cursor.fetchone()
role = Role(id=record[0], name=record[1])
return role
class UserRoleController:
def __init__(self, connection):
self.connection = connection
from models.user import User
from models.role import Role
from models.user_role import UserRole
self.user = User(connection)
self.role = Role(connection)
self.user_role = UserRole(connection)
def find_by_user_id(self, user_id):
user_roles = self.user_role.find({'user_id': user_id})
print user_roles
ids = [user_role['role_id'] for user_role in user_roles]
if ADMIN_ROLE_ID in ids:
params = {}
else:
ids = [
user_role['role_id'] for user_role in user_roles
if user_role['is_admin']
]
params = {'ids': ids}
print params
return self.role.find(params)
def find_by_role_id(self, role_id):
user_roles = self.user_role.find({'role_id': role_id})
print user_roles
ids = [row['user_id'] for row in user_roles]
params = {'ids': ids}
print params
return self.user.find(params)
class UserRoleController:
def __init__(self, connection):
self.connection = connection
from models.user import User
from models.role import Role
from models.user_role import UserRole
self.user = User(connection)
self.role = Role(connection)
self.user_role = UserRole(connection)
def find_by_user_id(self, user_id):
user_roles = self.user_role.find({'user_id': user_id})
print user_roles
ids = [ user_role['role_id'] for user_role in user_roles ]
if ADMIN_ROLE_ID in ids:
params = {}
else:
ids = [ user_role['role_id'] for user_role in user_roles if user_role['is_admin'] ]
params = {'ids': ids}
print params
return self.role.find(params)
def find_by_role_id(self, role_id):
user_roles = self.user_role.find({'role_id': role_id})
print user_roles
ids = [row['user_id'] for row in user_roles]
params = {'ids': ids}
print params
return self.user.find(params)
def role_revoke(id, role):
role = Role.find(role)
user = User.find(id).roles
old_roles = [(lambda y: y.name)(x) for x in user]
if role.name in old_roles:
db.table('roles_users').where('user_id', id).where('role_id', role).delete()
user_old = User.find(id)
updated_user = User.find(id).roles
updated_roles = [(lambda y: y.name)(x) for x in updated_user]
encoded = {'email': user_old.email,
'name': user_old.name,
'weight': user_old.weight,
'role': updated_roles}
data = jwt.encode(encoded, key=key, algorithm='HS256')
user_old.token = data;
save = user_old.save()
if save:
return jsonify({
'message': 'Access controls have been updated'
}), 202
else:
return jsonify({
'message': 'Some Tragedy has happen try again later'
}), 404
def update(self, **argv):
from models.role import Role
self.username = argv.get('username', self.username)
self.password = argv.get('password', self.password)
self.type_id = argv.get('type', self.type_id)
self.age = argv.get('age', self.age)
self.address = argv.get('address', self.address)
self.email = argv.get('email', self.email)
self.gender = argv.get('gender', self.gender)
if 'roles' in argv:
roles_to_add = argv['roles']['add'] and Role.get_mul(argv['roles']['add']) or None
roles_to_remove = argv['roles']['remove'] and Role.get_mul(argv['roles']['remove']) or None
self.change_roles(roles_to_remove, roles_to_add)
if 'recharge' in argv:
self.recharge(argv['recharge'])
session.commit()
def post(self):
from models.role import Role, RoleHasApi
from models.api import Api
from app import db
try:
role_id = request.json.get('id')
if not Role.check_role(self.app_id, role_id):
return '权限错误', 400
now_apis = request.json.get('api_ids')
old_apis = RoleHasApi.get_api(role_id)
need_delete = list(set(old_apis) - set(now_apis))
need_add = list(set(now_apis) - set(old_apis))
for n in need_add:
if Api.check_api(self.app_id, n):
m = RoleHasApi()
m.role_id = role_id
m.api_id = n
db.session.add(m)
for d in need_delete:
if Api.check_api(self.app_id, d):
m = RoleHasApi.query.filter_by(role_id=role_id,
api_id=d).first()
db.session.delete(m)
db.session.commit()
except Exception as e:
db.session.rollback()
def post(self):
body = request.get_json()
email = body["email"]
password = body["password"]
if email is None:
return {"msg": "email field is mandatory"}, 400
if password is None:
return {"msg": "password field is mandatory"}, 400
emp = Employee.find_by_email(email)
if not emp:
return {"msg": f"employee not found with email: {email}."}, 404
authorized = emp.check_password(password)
if not authorized:
return {"msg": f"wrong password"}, 401
roles = []
for row in Role.get_roles_by_emp_id(emp.json()["id"]):
roles.append(row["name"])
access_token = create_access_token(identity={
"email": emp.email,
"roles": roles
})
return {"access_token": access_token, "roles": roles}, 200
def run(self, email, role):
user = User.find_one_by(email=email)
role_obj = Role.find_one_by(name=role)
if user and role:
UserRole(user=user, role=role_obj).save()
self.stdout.write('User, {email}, now has role, {role_name}'.format(email=user.email, role_name=role_obj.name))
else:
self.stderr.write('Unable to find either user or role!')
def __init__(self, connection):
self.connection = connection
from models.user import User
from models.role import Role
from models.user_role import UserRole
self.user = User(connection)
self.role = Role(connection)
self.user_role = UserRole(connection)
def __init__(self, connection):
self.connection = connection
from models.role import Role
from models.user_role import UserRole
self.role = Role(connection)
self.user_role = UserRole(connection)
from token_controller import TokenController
self.token_controller = TokenController(connection)
from user_role_controller import UserRoleController
self.user_role_controller = UserRoleController(connection)
class RoleController:
def __init__(self, connection):
self.connection = connection
from models.role import Role
from models.user_role import UserRole
self.role = Role(connection)
self.user_role = UserRole(connection)
from token_controller import TokenController
self.token_controller = TokenController(connection)
from user_role_controller import UserRoleController
self.user_role_controller = UserRoleController(connection)
def is_admin(self, user_id):
row = self.user_role.find({'user_id': user_id, 'role_id': ADMIN_ROLE_ID})
if len(row) > 0: return True
else: return False
# only the admin can create a role
def create(self, access_token, params):
rows = self.token_controller.find(access_token)
user_id = rows[0]['user_id']
if not self.is_admin(user_id): raise Exception("not permitted")
self.role.create(params)
return True
def update(self, access_token, params):
raise Exception("not supported")
def delete(self, access_token, params):
raise Exception("not supported")
"""
1. find all roles if I'm the admin
2. find only roles where I'm the role admin
"""
def find_all(self, access_token, params=None):
rows = self.token_controller.find(access_token)
user_id = rows[0]['user_id']
return self.user_role_controller.find_by_user_id(user_id)
def find_one(self, access_token, params):
raise Exception("not supported")
import sys
sys.path.insert(0, r'../..')
from models.connection import connection
from models.role import Role
role = Role(connection)
print role.find({'id':'3867c370-552f-43b8-bed9-6aa00ffc41b4'})
print role.find({'ids':['435a6417-6c1f-4d7c-87dd-e8f6c0effc7a', 'ffffffff-ffff-ffff-ffff-ffffffffffff']})
print role.find({'ids':[]})
print role.find({})
print role.create({'id':'333', 'name':'333'})
#print role.create({'id':'ffffffff-ffff-ffff-ffff-ffffffffffff', 'name':'admin'})
#print role.create({'id':'435a6417-6c1f-4d7c-87dd-e8f6c0effc7a', 'name':'public'})
#print role.create({'id':'3867c370-552f-43b8-bed9-6aa00ffc41b4', 'name':'Awesome Role'})
