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 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 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 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 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 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 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 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 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 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 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 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 __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 __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 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 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 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 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))
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 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 add_role():
name = request.form.get('name')
role = Role(name=name, )
db.session.add(role)
db.session.commit()
return redirect(url_for('role'))
import asyncio
import random
import re
from dataclasses import dataclass, field
from datetime import datetime
from random import randrange, shuffle
from typing import List, Mapping
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")
CLERIC = Role(Team.GOOD, "cleric")
LUNATIC = Role(Team.EVIL, "lunatic")
REVEALER = Role(Team.EVIL, "revealer")
TRICKSTER = Role(Team.EVIL, "trickster")
TROUBLEMAKER = Role(Team.GOOD, "troublemaker")
def setUp(self) -> None:
self.service = Mock(spec=RoleService)
self.role = Role(name='test_admin', description='test')
# 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
from model import db, connect_to_db, Role, Organization
from server import app
connect_to_db(app)
db.drop_all()
db.create_all()
for name in ['superadmin', 'admin', 'donor', 'edit']:
role = Role(name)
db.session.add(role)
for i in range(3):
organization = Organization(
'The Lillith Fund {}'.format(i + 1),
"The Lillith Fund {} helps people pay for an abortion when they can't afford it."
.format(i + 1), 'http://lillithfund.org/', '*****@*****.**',
None)
organization.address = 'P.O. Box 759, Anytown, USA, 93856'
organization.template_hero_image = open('hero.jpg', 'rb').read()
db.session.add(organization)
db.session.commit()
print "DB created."
js = Category('Javascript')
p = Post('Hello Python!', 'Python is pretty cool', py)
p1 = Post('Python web', 'Python web is easy', py)
j = Post('Hello Javascript!', 'Javascript is pretty cool', js)
# db.session.add(py)
person1 = Person('张三')
person2 = Person('李四')
address1 = EmailAddress('*****@*****.**', person1)
address2 = EmailAddress('*****@*****.**', person2)
address3 = EmailAddress('*****@*****.**', person2)
address4 = EmailAddress('*****@*****.**', person2)
address5 = EmailAddress('*****@*****.**', person2)
ro1 = Role(name="admin")
# 先将ro1对象添加到会话中，可以回滚。
db.session.add(ro1)
# db.session.add_all([person1,person2])
# db.session.commit()
db.session.add_all([
admin, guest, py, p, person1, person2, js, j, address1, address2, address3,
address4, address5
])
db.session.commit()
a = person2.emails.all()
for email in a:
print(email.email)
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,
