def test_modify_role(app):
# app.session.login(user_email="*****@*****.**", password="******")
app.role.open_role_page()
old_roles = app.role.get_role_list()
role = Role(name="somenamenew", definition="Admin")
app.role.modify(role, Role(name="somename"))
new_roles = app.role.get_role_list()
assert len(old_roles) == len(new_roles)
old_roles[-1].name=role.name
assert old_roles == new_roles
def add_role():
form = AddRoleForm()
if form.validate_on_submit():
if not current_user.check_password(form.current_password.data):
form.current_password.errors.append('Your password is incorrect')
else:
role = Role.find_byname(form.role_name.data)
if role is not None:
form.role_name.errors.append('this role already exists')
else:
Role.add(form.role_name.data)
return render_template('accounts/addrole.html', form=form)
def add():
# create org
org_name = request.form['org_name']
org = controller.addOrg(org_name)
# create roles and assign admin rights to creating user
Role.add(org.get_resource() + '_admin')
Role.add(org.get_resource() + '_user')
current_user.add_to_role(role_name=org.get_resource() + '_admin')
current_user.add_to_role(role_name=org.get_resource() + '_user')
# return html
return redirect(url_for('organization_api.all'))
def deploy():
from flask_migrate import upgrade
from flask_migrate import init
from flask_migrate import migrate
from model.role import Role
from model.user import User
init(directory=migrationsdir)
migrate(directory=migrationsdir, message='initial migration')
upgrade(directory=migrationsdir)
# create roles
Role.insert_roles()
# make all users follow themselives.
User.add_self_follows()
def init():
handler = pugsql.module('assets/sql')
handler.connect('sqlite:///memory')
settings.sql = handler
# Create table if they don't exist
handler.org_create()
handler.user_create()
handler.prof_create()
handler.fund_create()
handler.stat_create()
handler.value_create()
handler.role_create()
handler.role_user_create()
# Add test rows if they don't exist
org = handler.org_find(id=1)
if (org == None):
org = Organization.add('Test Company')
admin = User.add('admin', 'test123')
guest = User.add('guest', 'test123')
admin_role = Role.add('admin')
admin.add_to_role(role_id=admin_role.id)
profile = Profile.add('Test Profile', org.id)
fund = Fund.add('Test Fund', 'Test Manager', 2000, 0.00, 0.00,
profile.id)
# return the queries handler
return handler
def get_tables(self):
cnds = self.navb.conditions() #;print cnds
if self.navb.kw.get("search") and self.navb.kw.get("identity"):
mkw = self.navb.kw.get('identity').strip()
if self.navb.kw.get("search") == 'code':
cnds.update({"code = %s": mkw})
exts = {}
attrs = []
cnds, markup, cols = self.navb.neater_tables(cnds=cnds,
extras=[
('indexcol', 'ID'),
('code', 'Code'),
('name', 'Name'),
])
markup.update({
'indexcol':
lambda x, _, __:
'<a href="/dashboards/report?tbl=role&id=%s">View</a>' % (x),
})
DESCRI = []
INDICS = []
group = "Role"
title = "Role List"
dcols = [x[0] for x in cols]
nat = Role.fetch_roles_table(cnds, dcols)
desc = 'Roles%s' % (
' (%s)' %
(self.navb.find_descr(DESCRI + INDICS, self.navb.kw.get('role'))))
#print INDICS, title, group, attrs, "NAT: ", nat[0].__dict__
self.navb.kw = {}
return (title, desc, group, attrs, markup, cols, nat)
def get_total(self):
cnds = self.navb.conditions()
exts = {}
cols = ['COUNT(*) AS total']
total = Role.get_roles_summary(cnds, cols)[0]
self.navb.kw = {}
return total
def get_stats(self):
cnds = self.navb.conditions()
cols = ['COUNT(*) AS total']
exts = {}
attrs = []
nat = Role.get_roles_summary(cnds, cols)
self.navb.kw = {}
return [nat, attrs]
def post(db_session: Session, request: CreateRole) -> Optional[Role]:
role = Role(
name=request.name,
description=request.description
)
db_session.add(role)
db_session.commit()
return role
def remove_from_role(self, role_name=None, role_id=None):
if role_id is None:
role = Role.find_byname(role_name)
if role is None:
raise ValueError(
'There is no role by the name of {role}'.format(
role=role_name))
role_id = role.id
settings.sql.user_remove_from_role(user_id=self.id, role_id=role_id)
def test_create_role(app):
# app.session.login(user_email="*****@*****.**", password="******")
app.role.open_role_page()
role = Role(name="somename", definition="Admin")
old_roles = app.role.get_role_list()
app.role.create(role)
new_roles = app.role.get_role_list()
assert len(old_roles) + 1 == len(new_roles)
old_roles.append(role)
assert old_roles == new_roles
def test_delete_role(app):
# app.session.login(user_email="*****@*****.**", password="******")
app.role.open_role_page()
role = Role(name="somename", definition="Admin")
if not app.role.role_is_exists(role):
app.role.create(role)
old_roles = app.role.get_role_list()
# app.role.create(Role(name="somename", definition="Admin"))
app.role.delete(role)
new_roles = app.role.get_role_list()
assert len(old_roles) - 1 == len(new_roles)
old_roles = old_roles[0:-1]
assert old_roles == new_roles
def user_search(self, search_term, resource):
roles = Role.find_byresource(resource)
if search_term == '*':
role_assignments = Role.get_all_role_assignments_for_roles(roles)
users = User.get_many_users_by_ids([x for x in role_assignments])
else:
users = User.search(search_term)
role_assignments = Role.get_role_assignments_for_users(
users, roles)
result = {'users': [], 'roles': []}
for user in users:
print(user.username)
result['users'].append({
'id': user.id,
'name': user.username,
'roles': role_assignments[user.id]
})
result['roles'] = [{'id': x.id, 'name': x.name} for x in roles]
return result
def get_role(self, account):
'''
:type account: Account
:rtype: List[Role]
'''
cursor = self.qn.cursor()
cursor.execute("select name, career from role where account = %d" %
account.id)
res = cursor.fetchall()
roles = []
for line in res:
role = Role(line[0], line[1])
roles.append(role)
return roles
def register_role(self):
cnds = self.navb.conditions()
message = ''
role = None
if self.navb.kw.get("rolename") and self.navb.kw.get('rolecode'):
formdata = {
"code": self.navb.kw.get('rolecode'),
"name": self.navb.kw.get('rolename')
}
#print "\nFORM: ", formdata, "\n"
message, role = Role.get_or_create(formdata)
self.navb.kw = {}
return [message, role]
def get_role_list(self):
if self.role_cash is None:
driver = self.app.driver
self.role_cash = []
for elements in driver.find_elements_by_css_selector(
"div.ui-grid-row.ng-scope"):
name_column = elements.find_element_by_css_selector(
"span.float-left.ng-binding.ng-scope") #.get_text()
name = name_column.text
def_column = elements.find_element_by_css_selector(
"div.ui-grid-cell-contents.ng-binding.ng-scope"
) #.get_text()
definition = def_column.text
self.role_cash.append(Role(name, definition))
# for elements in driver.find_elements_by_css_selector("span.float-left.ng-binding.ng-scope"):
# text = elements.get_text()
return list(self.role_cash)
def choose_role(self):
roles = self.act.list_role()
while 1:
x = input(STR_CHOOSE % len(roles))
try:
i = int(x)
if 0 <= i <= len(roles):
if i == 0:
name = input(STR_INPUT_NAME)
career = input(STR_INPUT_CAREER)
role = Role(name, career)
self.act.add_role(role)
self.choose_role()
else:
self.role = roles[i-1]
break
except:
pass
def add_to_role():
form = AddUserToRoleForm()
if form.validate_on_submit():
if not current_user.check_password(form.current_password.data):
form.current_password.errors.append('Your password is incorrect')
else:
user = User.find_byname(form.target_username.data)
if user is None:
form.target_username.errors.append(
'Specified username does not exist')
role = Role.find_byname(form.role_name.data)
if role is None:
form.role_name.errors.append('Specified role does not exist')
if user is not None and role is not None:
if not form.remove_instead.data:
user.add_to_role(role_name=form.role_name.data)
else:
user.remove_from_role(role_name=form.role_name.data)
return render_template('accounts/addusertorole.html', form=form)
def init():
for role, access in ROLES.items():
res = []
perm = []
for a in access:
if(a["RESOURCE"] not in RESOURCE_DB):
raise Exception("Resource not found in db")
resource = RESOURCE_DB[a["RESOURCE"]]
permission = tuple(a["ACCESS"])
res.append(resource)
perm.append(permission)
r = Role(role, res, perm)
ROLE_DB[role] = r
for user in USERS:
roles = []
for role in USERS[user]:
if(role not in ROLE_DB):
raise Exception("Role not found")
roles.append(ROLE_DB[role])
u = User(user, roles)
USER_DB[user] = u
def add_role_api(role_name):
Role.add(role_name)
return ''
def test_roles_and_permissions(self):
Role.insert_roles()
u = User(email='*****@*****.**', password='******')
self.assertTrue(u.can(Permission.WRITE_ARTICLES))
self.assertTrue(u.can(Permission.MODERATE_COMMENTS))
def setUp(self):
from model.role import Role
db.create_all()
role = Role(name='investor')
db.session.add(role)
db.session.commit()
def create_role(self, name):
db.session.add(Role(name=name))
db.session.commit()
return Role.query.filter_by(name=name).first()
def list_roles(self):
lst = settings.sql.user_get_roles(user_id=self.id)
result = []
for item in lst:
result.append(Role(item))
return result
