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!')
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'})