def register():
form = RegisterForm()
Role.insert_roles()
if current_user.is_active():
return redirect(url_for('landing_blueprint.index'))
else:
if form.validate_on_submit():
user = User(username=request.form['username'],
email=request.form['email'],
password=request.form['password'],
role_id=3)
db.session.add(user)
db.session.commit()
# Add same info to session for new user as per /login route
session["current_user"] = {
"first_name": user.first_name,
"id": user.id,
"num_received_requests": 0,
"num_sent_requests": 0,
"num_total_requests": 0
}
flash('Log In')
return redirect(url_for('auth_blueprint.login'))
return render_template('users/registration.html', form=form)
def setup():
db.create_all()
role_teacher = Role(name='Teacher')
role_student = Role(name='Student')
role_admin = Role(name='Admin')
db.session.add_all([role_teacher, role_student, role_admin])
db.session.commit()
def insert_basic_data(engine):
Session = sessionmaker(engine)
session = Session()
dept = Dept(name='总部', desc='公司总部')
session.add(dept)
session.flush()
admin = User(name='admin',
password=utils.md5encode('admin'),
dept_id=dept.id)
session.add(admin)
sys_admin_role = Role('系统管理员', '系统管理员')
dept_admin_role = Role('部门管理员', '部门管理员')
user_role = Role('普通用户', '普通用户')
session.add(sys_admin_role)
session.add(dept_admin_role)
session.add(user_role)
session.flush()
membership1 = UserRoleMembership(user_id=admin.id,
role_id=sys_admin_role.id)
session.add(membership1)
session.commit()
session.close()
def get_role(role_id=None, role_name=None):
if role_id != None:
role = Role.get_by_key(role_id)
else:
query = Role.all()
query.filter("role_name =", role_name)
role = query.get()
return role
def post(self):
args = self.parser.parse_args()
only_admins_authorized(args['Authorization'])
r = Role.query.filter_by(name=args['name']).first()
if r is not None:
abort(400, message="Role already exists")
else:
r = Role(name=args['name'])
r.insert()
return {'role': marshal(r, role_fields)}, 201
def create_role(self, rolename, permissions=[]):
r = Role(rolename=rolename)
r.last_changed_by = "Unknown"
r.last_change_date = datetime.now()
for permission in permissions:
r.permissions.append(Permission(rolename=r.rolename, permission=permission))
self.session.add(r)
self.session.commit()
return r
def create_role(self, rolename, permissions=[]):
r = Role(rolename=rolename, permissions=permissions)
r.id = self.calculate_id(rolename)
r.create_date = datetime.now()
r.change_date = r.create_date
r.created_by = "UNBEKANNT"
r.type = self.TYPE_KEY
r.store(self.db)
return r
def createdb(init=True):
"""creer la base de donnee
a partir de la liste des tables presentent dans le module
models
"""
import model
from sqlobject import SQLObject, sqlhub
from model import Users, Groupe, Role
constraints = []
for (name, table) in vars(model).iteritems():
if (inspect.isclass(table)) and (issubclass(
table, SQLObject)) & (table != SQLObject):
if context.conf["sgbd"] == "postgresql":
constraints.extend(
table.createTable(applyConstraints=False, ifNotExists=True)
) # True pour ne pas creer la table si elle existe deja
else:
table.createTable(ifNotExists=True)
print "Creation de la table `" + name + '` OK'
# Les contraintes ne sont ajoute qu'a la fin (pour postgresql)
if context.conf["sgbd"] == "postgresql":
if constraints:
for constraint in constraints:
if constraint:
sqlhub.processConnection.query(constraint)
if not init:
return
#ajout d'un groupe par default, role et association (ne rien faire si il existe deja)
if not list(Groupe.select(Groupe.q.nom == 'visiteur')): #.
groupe = Groupe(nom="visiteur")
if not list(Role.select(Role.q.name == 'visiteur')): #.
role = Role(name="visiteur")
groupe.addRole(role)
#Ajout d'un groupe admin et d'un admin (ne rien faire si il existe deja)
if not list(Users.select(Users.q.pseudo == 'admin')): #.
user = Users(nom="", prenom="", pseudo="admin", password="******")
print "\n--> Creation d'un compte `admin` mot de passe : `nimda`"
groupe = Groupe(nom="admin")
role = Role(name="admin")
groupe.addRole(role)
user.addGroupe(groupe)
print "Tables crees avec succes\n"
def register():
form = RegisterForm()
Role.insert_roles()
if current_user.is_active():
return redirect(url_for('landing_blueprint.index'))
else:
if form.validate_on_submit():
user = User(username=request.form['username'],
email=request.form['email'],
password=request.form['password'],
role_id=3)
db.session.add(user)
db.session.commit()
flash('Log In')
return redirect(url_for('auth_blueprint.login'))
return render_template('users/registration.html', form=form)
def get(self):
if(not isUserAdmin(self)):
self.session[LOGIN_NEXT_PAGE_KEY] = self.URL
self.redirect("/")
return
pageText=self.request.get("page")
pageSize=20
actualPage=0
if (pageText!=None and pageText!=""):
actualPage=int(pageText)-1
orderByText=self.request.get("order")
if (orderByText==None or orderByText==""):
orderByText='familyName'
userCount=User.all().count()
roles=Role.all().order("name")
usersToDisplay=User.all().order(orderByText).run(offset=actualPage*pageSize, limit=pageSize)
pages=[]
corrector=1
if (userCount/pageSize) * pageSize == userCount:
corrector=0
for i in range(0,userCount/pageSize + corrector):
pages.append(i+1)
template_values={
'page':actualPage+1,
'pages':pages,
'userList':usersToDisplay,
'order':orderByText,
'roles':roles
}
if actualPage < userCount/ pageSize - 1 - corrector:
template_values["nextPage"]=actualPage + 2
if actualPage > 0:
template_values["nextPage"]=actualPage
template = jinja_environment.get_template('templates/userList.html')
self.printPage("Felhasznalok", template.render(template_values), False, False)
def create_role(self, rolename, permissions=[]):
r = Role(rolename=rolename, permissions=permissions)
r.id = self.calculate_id(rolename)
r.create_date = datetime.now()
r.change_date = r.create_date
r.created_by = "UNBEKANNT"
r.type = self.TYPE_KEY
r.store(self.db)
return r
def put(self):
args = update_role_parser.parse_args()
id = args['id']
name = args['name']
description = args['description']
self.service.update_role(
Role(id=id, name=name, description=description))
return self.service.find_role_by_name(name)
def get(self):
roles=Role.all()
if roles.count() == 0:
template = jinja_environment.get_template('templates/setup/setup.html')
self.printPage("Weboldal nicializálása", template.render(), True, True)
else:
template = jinja_environment.get_template('templates/setup/alreadySetUp.html')
self.printPage("Korábban inicializálva", template.render(), True, True)
def update_role(self, role):
r = Role.load(self.db, role.id)
r.permissions = role.permissions
r.last_change_date = datetime.now()
r.last_changed_by = 'blubblub'
r.store(self.db)
def delete_role(role_id, modifier_id):
query = UserRole.all()
query.filter("role_id =", role_id)
if query.count() > 0 :
raise CoreError("The role %s is set to user, can not be deleted." % role_id)
role = Role.get_by_key(int(role_id))
delete_roleoperations(role_id=role_id)
role.delete(modifier_id)
def post(self):
args = role_parser.parse_args()
name = args['name']
description = args['description']
if not self.service.is_exist(name):
self.service.create_role(Role(name=name, description=description))
return self.service.find_role_by_name(name)
else:
return Response('role already exist')
def create_role(self, rolename, permissions=[]):
r = Role(rolename=rolename)
for permission in permissions:
r.permissions.append(
Permission(rolename=r.rolename, permission=permission))
self.session.add(r)
self.session.commit()
return r
def add_new(self, role_id, entity_id, entity, role):
new_role = Role(role_id=role_id,
entity_id=entity_id,
entity=entity,
role=role)
db_session.add(new_role)
db_session.commit()
return new_role
def add_role():
name = request.form.get('name')
try:
role = Role(name=name, )
db.session.add(role)
db.session.commit()
except Exception:
flash('')
return redirect(url_for('role'))
return redirect(url_for('role'))
def test_search_roles(self):
"""
Test the role search by name in ldap
"""
print_ln('test search roles by name')
try:
rle = Role(name = 'oam*')
rList = roledao.search(rle)
for idx, entity in enumerate(rList) :
print_role(entity, "Role[" + str(idx+1) + "]:")
except Exception as e:
self.fail('role search failed, exception=' + str(e))
def __unload(entry):
entity = Role()
entity.dn = ldaphelper.get_dn(entry)
entity.internal_id = ldaphelper.get_attr_val(
entry[ATTRIBUTES][global_ids.INTERNAL_ID])
entity.name = ldaphelper.get_attr_val(entry[ATTRIBUTES][ROLE_NAME])
entity.description = ldaphelper.get_one_attr_val(
entry[ATTRIBUTES][global_ids.DESC])
# Get the multi-occurring attrs:
entity.props = ldaphelper.get_list(entry[ATTRIBUTES][global_ids.PROPS])
# unload raw constraint:
entity.constraint = Constraint(
ldaphelper.get_attr_val(entry[ATTRIBUTES][global_ids.CONSTRAINT]))
return entity
def test_delete_roles(self):
"""
Test the role delete
"""
print_ln('test delete roles')
try:
rList = roledao.search(Role(name='py-test*'))
for rle in rList:
rle = roledao.delete(rle)
print_ln("Role Delete role=" + rle.name)
except Exception as e:
self.fail('role delete failed, exception=' + str(e))
def update_role(self, role):
# 1. Bisherigen Stand in die Historie schreiben
# self.db.add_attachment
r_doc = self.db[role.id]
json_string = json.dumps(r_doc)
filename = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
self.db.put_attachment(r_doc, json_string, filename, content_type='application/json')
# 2. Daten aktualisieren
r = Role.load(self.db, role.id)
r.permissions = role.permissions
r.change_date = datetime.now()
r.store(self.db)
def test_delete_role(self):
"""
Test the role delete user method
"""
print_ln('test_delete_role')
try:
rList = review_mgr.find_roles(Role(name='py-role*'))
for rle in rList:
entity = admin_mgr.delete_role(rle)
print_ln("Delete role=" + entity.name)
except Exception as e:
self.fail('test_delete_role failed, exception=' + str(e))
def update_role(self, role, permissions):
r = self.session.query(Role).filter(Role.rolename == role.rolename)\
.filter(Role.valid_until == ModelUtility.NullTimeStamp).first()
# 1. Aktuellen Stand der Rolle als Version sichern
r_version = Role(rolename=r.rolename, valid_until=datetime.now())
r_version.last_change_date = r.last_change_date
r_version.last_changed_by = r.last_changed_by
r_version.permissions = []
for permission in r.permissions:
r_version.permissions.append(Permission(role=r, permission=permission.permission))
self.session.add(r_version)
# 2. Rolle aktualisieren
r.permissions = []
for permission in permissions:
r.permissions.append(Permission(role=r, permission=permission))
r.last_change_date = datetime.now()
r.last_changed_by = 'blub'
self.session.add(r)
self.session.commit()
def ajax_add_role():
data = request.get_data()
data = json.loads(data)
print('ajax_add_role')
print(data)
role = data['role']
chi_name = data['chi_name']
# for i in role:
# if i > u'\u4e00' or i < u'\u9fff':
# return jsonify({'msg': 'Role不能有中文'})
new = Role(role=role, chi_name=chi_name)
db1.add(new)
db1.commit()
return jsonify({'msg': '成功'})
def __create_test_role(name, number):
label = name + '-' + str(number)
return Role(name=label,
description=label + ' Role',
constraint=Constraint(name=label,
timeout=TIMEOUT,
begin_time=BEGIN_TIME,
end_time=END_TIME,
begin_date=BEGIN_DATE,
end_date=END_DATE,
begin_lock_date=BEGIN_LOCK_DATE,
end_lock_date=END_LOCK_DATE,
day_mask=ALL))
def update_role(self, role):
r = Role.load(self.db, role.id)
# 1. Bisherigen Stand in die Historie schreiben
r.previous_versions.append(permissions=r.permissions,
version_create_date=r.change_date,
version_created_by='UNBEKANNT',
version_valid_until=datetime.now())
# 2. Daten aktualisieren
r.permissions = role.permissions
r.change_date = datetime.now()
r.store(self.db)
def test_assigned_users(self):
"""
Test the assigned users method
"""
print_ln('test_assigned_users')
try:
rList = review_mgr.find_roles(Role(name='py-role*'))
for rle in rList:
print_ln("Assigned users role=" + rle.name)
uList = review_mgr.assigned_users(rle)
for user in uList:
print_ln("Assigned user=" + user, 1)
except Exception as e:
self.fail('test_assigned_users failed, exception=' + str(e))
def update_role(self, role):
r = Role.load(self.db, role.id)
# 1. Bisherigen Stand in die Historie schreiben
r.previous_versions.append(
permissions=r.permissions,
version_create_date=r.change_date,
version_created_by='UNBEKANNT',
version_valid_until=datetime.now()
)
# 2. Daten aktualisieren
r.permissions = role.permissions
r.change_date = datetime.now()
r.store(self.db)
def find_one(self, id):
response = requests.get("%s/%s" % (self.url, id))
if(response.ok):
data = response.json()
if data is not None:
return Camera(
float(data["focalLength"]),
float(data["height"]),
np.array([data["aDistance"], data["bDistance"], data["cDistance"]], dtype=np.float64),
np.array([
[data["aX"], data["aY"]],
[data["bX"], data["bY"]],
[data["cX"], data["cY"]],
], dtype=np.float64),
[ Role(role["id"], role["description"],
[Action(action["id"], action["description"]) for action in role["actions"]]) for role in data["roles"]])
def create_role(role_name):
''' create a Role in the current users Profile '''
if role_name is None:
raise ActionException('Role name is required')
my_profile = _get_my_profile()
role = Role(name=role_name, parent=my_profile.key)
role.name = role_name
role.name_order = role_name.upper()
role.updated = datetime.now()
role.put()
return role.key.urlsafe()
def createdb(init=True):
"""creer la base de donnee
a partir de la liste des tables presentent dans le module
models
"""
import model
from sqlobject import SQLObject, sqlhub
from model import Users, Groupe, Role
constraints = []
for (name, table) in vars(model).iteritems():
if (inspect.isclass(table)) and (issubclass(table, SQLObject)) & (table != SQLObject):
if context.conf["sgbd"] == "postgresql":
constraints.extend(table.createTable(applyConstraints=False, ifNotExists=True)) # True pour ne pas creer la table si elle existe deja
else:
table.createTable(ifNotExists=True)
print "Creation de la table `"+name+'` OK'
# Les contraintes ne sont ajoute qu'a la fin (pour postgresql)
if context.conf["sgbd"] == "postgresql":
if constraints:
for constraint in constraints:
if constraint:
sqlhub.processConnection.query(constraint)
if not init:
return
#ajout d'un groupe par default, role et association (ne rien faire si il existe deja)
if not list(Groupe.select(Groupe.q.nom=='visiteur')):#.
groupe = Groupe(nom="visiteur")
if not list(Role.select(Role.q.name=='visiteur')):#.
role = Role(name="visiteur")
groupe.addRole(role)
#Ajout d'un groupe admin et d'un admin (ne rien faire si il existe deja)
if not list(Users.select(Users.q.pseudo=='admin')):#.
user = Users(nom="", prenom="", pseudo="admin", password="******")
print "\n--> Creation d'un compte `admin` mot de passe : `nimda`"
groupe = Groupe(nom="admin")
role = Role(name="admin")
groupe.addRole(role)
user.addGroupe(groupe)
print "Tables crees avec succes\n"
def postRole():
if not request.json:
json_abort({'err_msg': 'request should be a json type!'}, 400)
try:
name = request.json['name']
permission = int(request.json['permission'])
except Exception:
json_abort({'err_msg': 'invalid json data'}, 400)
role = Role.query.filter(Role.name == name).first()
if role:
json_abort({'err_msg': '该角色已存在！'}, 400)
role = Role(name=name, permission=permission)
db.session.add(role)
db.session.flush()
_id = role.id
db.session.commit()
return '{ "id" : %d }' % _id
def test_role_perms(self):
"""
Test the role perms method
"""
print_ln('test_role_perms')
try:
rList = review_mgr.find_roles(Role(name='py-role*'))
for rle in rList:
print_ln("Perm Roles name=" + rle.name)
pList = review_mgr.role_perms(rle)
for perm in pList:
print_ln(
"Assigned perm obj name=" + perm.obj_name +
', op name=' + perm.op_name + ', obj id=' +
perm.obj_id, 1)
except Exception as e:
self.fail('test_role_perms failed, exception=' + str(e))
class TestRoleService(unittest.TestCase):
def setUp(self) -> None:
self.service = Mock(spec=RoleService)
self.role = Role(name='test_admin', description='test')
def test_create_role(self):
self.service.create_role.return_value = {
'name': 'test_admin',
'description': 'test'
}
result = self.service.create_role(self.role)
self.service.create_role.assert_called_once()
assert result['name'] == 'test_admin'
def test_list_role(self):
self.service.list_role.return_value = [self.role.as_dict()]
result = self.service.list_role()
self.service.list_role.assert_called_once()
assert len(result) == 1
def has_permission(user_id, operation_key, oqlparams=None):
b = False
cachekey = '%d:%s:%r' % (user_id, operation_key, oqlparams)
perm = cache.get(CACHESPACE_PERMISSION, cachekey)
if perm != None:
return perm
query = stdModel.all()
query.model(UserRole.get_modelname(), "a")
query.model(Role.get_modelname(), "b", join="inner", on="a.role_id=b.uid")
query.model(RoleOperation.get_modelname(), "c", join="inner", on="c.role_id=b.uid")
query.model(Operation.get_modelname(), "d", join="inner", on="c.operation_key=d.operation_key")
query.what("a.user_id", alias="user_id")
query.what("b.uid", alias="role_id")
query.what("d.operation_key", alias="operation_key")
query.what("d.handler_classes", alias="handler_classes")
query.what("d.resource_oql", alias="resource_oql")
query.what("a.user_id", alias="user_id")
query.filter("a.user_id =", user_id)
if operation_key is not None:
query.filter("d.operation_key =", operation_key)
std = query.get()
if std != None:
if std.resource_oql != None:
operation = get_operation(operation_key=operation_key)
params = operation.get_resource_oql_paramnames()
if len(params) != len(oqlparams):
raise UnauthorizedError()
query = stdModel.all()
if oqlparams != None and len(oqlparams) > 0 :
query = query.sql(std.resource_oql, sql_vars=oqlparams)
else:
query = query.sql(std.resource_oql)
if query.count() > 0:
b = True
else:
b = True
cache.put(CACHESPACE_PERMISSION, cachekey, b)
return b
def post(self):
if(not isUserAdmin(self)):
self.redirect("/")
return
# Save user
userKey=self.request.get("userKey")
if userKey!=None and userKey!="":
userToChange=User.get(userKey)
user=getUser(self)
# Can't change own account for safety reasons
if user.key() == userToChange.key():
self.redirect("/userList")
return
else:
userToChange.activated = self.request.get("activated")=="on"
roleKey=self.request.get("role")
if roleKey!=None and roleKey != "":
userToChange.role=Role.get(roleKey)
else:
userToChange.role=None
userToChange.put()
self.redirect("/userList")
import re
import shelve
from datetime import datetime
from random import randrange, shuffle
from dataclasses import dataclass, field
from typing import List, Mapping
import discord
from discord import DMChannel
from model import Team, Phase, Role, Quest, Player
from msgqueue import MsgQueue
from skins import Skin, Skins
from strings import StringSet, StringSets
SERVANT = Role(Team.GOOD, "servant")
MINION = Role(
Team.EVIL,
"minion",
)
MERLIN = Role(Team.GOOD, "merlin")
PERCIVAL = Role(Team.GOOD, "percival")
ASSASSIN = Role(Team.EVIL, "assassin")
MORGANA = Role(Team.EVIL, "morgana")
MORDRED = Role(Team.EVIL, "mordred")
OBERON = Role(Team.EVIL, "oberon")
NAME_TO_ROLE = {
'servant': SERVANT,
'minion': MINION,
'merlin': MERLIN,
def create_role(self, rolename, permissions=[]):
r = Role(rolename=rolename, permissions=permissions)
r.id = self.calculate_id(rolename)
r.type = 'role'
r.store(self.db)
return r
def fetch_roles(operation_key):
query = Role.all("a")
query.model(RoleOperation.get_modelname(), "b", join="inner", on="a.role_id = b.role_id")
query.filter("b.operation_key =", operation_key)
return query.fetch()
def add_role():
name = request.form.get('name')
role = Role(name=name, )
db.session.add(role)
db.session.commit()
return redirect(url_for('role'))
def create_role(role_name, modifier_id):
role = Role(role_name=role_name)
role.create(modifier_id)
return role
def post(self):
self.session[LOGIN_NEXT_PAGE_KEY] = self.URL
roles=Role.all()
if roles.count() == 0:
# No roles were set up, set them up now
adminRole = Role()
adminRole.name=ROLE_ADMIN
adminRole.put()
role = Role()
role.name=ROLE_DELIVERY_GUY
role.put()
role = Role()
role.name=ROLE_COOK
role.put()
role = Role()
role.name=ROLE_AGENT
role.put()
user = User()
user.email = self.request.get("adminEmail")
user.password = "******"
m = hashlib.md5()
encodedString = self.request.get("adminPassword").encode('ascii', errors='replace')
m.update(encodedString)
user.passwordHash = str(m.hexdigest())
user.activated = True
user.role = adminRole
user.put();
template = jinja_environment.get_template('templates/setup/setupSuccess.html')
self.printPage("Sikeres inicializálás", template.render(), True, True)
else:
template = jinja_environment.get_template('templates/setup/alreadySetUp.html')
self.printPage("Korábban inicializálva", template.render(), True, True)
def get_my_roles():
''' get the Roles in the current users Profile '''
return [get_role_properties(role) for role in Role.query(ancestor=_get_my_profile().key).order(Role.name_order).fetch()]
# page.contents='<h1> Hallo Dunia ? apa kabar... </h1>'
# page.is_homepage=False
# page.url='page/hallo-dunia'
# page.image_id=1
# db.session.add(page)
# db.session.commit()
gbr=Image()
x=gbr.query.filter_by(path='beranda.jpeg').first()
if x is None:
gbr.path='beranda.jpeg'
db.session.add(gbr)
db.session.commit()
role = Role()
x=role.query.filter_by(name='admin').first()
# db.session.delete(x)
# db.session.commit()
if x is None :
role.name='admin'
role.description='admin'
db.session.add(role)
db.session.commit()
user = User()
y=user.query.filter_by(email='*****@*****.**').first()
if y is None:
user.email='*****@*****.**'
user.password='******'
user.active=True
""" Script to add sample data in the database """ from model import User, Role, Item, Category from catalog import db # Add roles Role.insert_roles() # Add users user1 = User(name='John', email='*****@*****.**', password='******') user2 = User(name='Mary', email='*****@*****.**', password='******') user3 = User(name='Bob', email='*****@*****.**', password='******') user4 = User(name='Mike', email='*****@*****.**', password='******') user5 = User(name='Estella', email='*****@*****.**', password='******') # Add users in the db session db.session.add(user1) db.session.add(user2) db.session.add(user3) db.session.add(user4) db.session.add(user5) # Add Categories category1 = Category(name='Exercise and Fitness') category2 = Category(name='Cricket') category3 = Category(name='Camping and Hiking') category4 = Category(name='Cycling') category5 = Category(name='Running')
def get_role_by_name(self, rolename):
r = Role.load(self.db, self.calculate_id(rolename))
return r
