def create_game(args):
number_of_user, number_of_edge, epsilon = args.user, args.edge, args.epsilon
number_of_chs = np.array([random.randint(args.min_chs, args.max_chs) for x in range(number_of_edge)])
cpu = np.array([random.uniform(args.min_cpu, args.max_cpu) * math.pow(10, 9) for x in range(number_of_edge)])
H = [[round(np.random.rayleigh(np.sqrt(2 / np.pi) * math.pow(10, -3)), 5) for y in range(number_of_edge)] for x
in range(number_of_user)]
d_cpu = np.array([random.uniform(1.5, 2.5) * math.pow(10, 9) for x in range(number_of_user)])
player = Role(number_of_edge=number_of_edge, number_of_user=number_of_user, epsilon=epsilon,
number_of_chs=number_of_chs, cpu=cpu, d_cpu=d_cpu, H=H)
player.initial_DAG()
# player.initial_config_DAG()
return player
def refreshCallback(self,data):
roleIds = [r.getId() for r in self.children]
for role in data:
if role['id'] not in roleIds:
self.addChild(Role(self,role))
else:
self.getRoleById(role['id']).refresh(role)
def get_role_by_name(self, rolename):
r = self.session.query(RoleEntity).filter(RoleEntity.rolename == rolename).\
filter(RoleEntity.deleted == False).first()
if r is None:
raise Exception("Die Rolle {0} ist gelöscht oder existiert nicht".format(rolename))
role = Role(rolename=r.rolename)
role.deleted = r.deleted
role.create_date = r.create_date
role.permissions = []
for permission in r.current_version.permissions:
role.permissions.append(permission.permission)
return role
def add_role(role_name):
''' Creates a new role '''
if not are_valid_roles([role_name]):
roles[role_name] = Role(role_name)
return True
else:
return False
def show_Roles():
display.clear_output()
reg = Registrar()
response = reg.openDBConnectionWithBundle("PgBundle.properties")
roles = reg.getAllRoles()
reg.closeConnection()
rolesTable = Role.showAsTable(roles)
display.display(rolesTable)
def get_history(self, rolename):
role = self.session.query(RoleEntity).filter(RoleEntity.rolename == rolename).\
filter(RoleEntity.deleted == False).first()
if role is None:
raise Exception("Die Rolle {0} ist gelöscht oder existiert nicht".format(rolename))
history = role.history
result = []
for version in history:
r = Role(rolename=role.rolename, create_date=role.create_date, deleted=role.deleted)
r.permissions = []
for permission in version.permissions:
r.permissions.append(permission.permission)
result.append(r)
return result
async def read_roles_from_file(self):
roles = self.legacy.split("\n")
guild_roles = await self.guild.fetch_roles()
for role in roles:
r = role.split(",")
guild_role: discord.Role
for guild_role in guild_roles:
if r[0].lower().replace(" ", "") == str(
guild_role.name).lower().replace(" ", ""):
self.roles.append(Role(role=guild_role))
def create_role():
if CURRENT_USER.check_permissions('write', 'role'):
role_name = input('Enter role name: \n')
permission = input('Enter permission in format "action$resource"\n')
new_role = Role(role_name, [
permission,
])
ROLES_MAP[role_name] = new_role
return 'Role created successfully'
return 'You dont have permission'
def test_query_all(self):
# 查询所有相同name数据测试
# isSuccess = self.helper.addRole(Role("admin", "CRUD"))
# self.assertTrue(isSuccess)
# isSuccess = self.helper.addRole(Role("normal", "CR"))
# self.assertFalse(isSuccess)
# isSuccess = self.helper.addRole(Role("visitor", "R"))
# self.assertFalse(isSuccess)
userList=self.helper.query_all_with_role_role_function(Role("admin", "CRUD"))
# print userList
self.assertEqual(len(userList),1)
def getRoleComponent(self, rolename):
if (rolename == "All"):
rolename = "%"
role = None
query = "select * from roles where rolename like '" + str(
rolename) + "'"
row = DBUtils.getRow(self._conn, query)
role = Role(row[0], row[1], row[2], row[3], row[4], row[5], row[6],
row[7], row[8], row[9], row[10], row[11], row[12], row[13],
row[14])
return role
def list_roles(self):
roles = self.session.query(RoleEntity).filter(RoleEntity.deleted == False).all()
result = []
for role in roles:
r = Role(rolename=role.rolename)
r.create_date = role.create_date
r.deleted = False
r.permissions = []
# wenn noch keine current_version existiert
if role.current_version is None:
for permission in role.future_version.permissions:
r.permissions.append(permission.permission)
# ansonsten natürlich die current_version verwenden
else:
for permission in role.current_version.permissions:
r.permissions.append(permission.permission)
result.append(r)
return result
def __init__(self, *roles: discord.Role, **kwargs):
self.roles = []
self.guild = None
if kwargs.get("guild") is None:
for role in roles:
self.roles.append(Role(role=role))
self.guild = role.guild
else:
try:
self.guild = kwargs.get("guild")
self.legacy = kwargs.get("")
except Exception:
print(getTimeStamp(), "Failed to read RoleMessage from file")
def show_Audit_Tables(num):
display.clear_output()
reg = Registrar()
response = reg.openDBConnectionWithBundle("PgBundle.properties")
audit = reg.getAudits(num)
audittable = None
if (num == 1):
audittable = Employee.showAsTable2(audit)
elif (num == 2):
audittable = EmployeeRole.showAsTable2(audit)
else:
audittable = Role.showAsTable2(audit)
reg.closeConnection()
display.display(display.HTML(audittable.to_html()))
from Role import Role from RoleRepository import RoleRepository repo = RoleRepository() r1 = Role(rolename="Beispielrolle") r1.permissions = ['Berechtigung 1'] role = repo.create_role(r1)
def build(objtId, p):
if (p.__class__.__name__ == 'AttackerParameters'):
return Attacker(objtId, p.name(), p.description(), p.image(), p.tags(),
p.environmentProperties())
if (p.__class__.__name__ == 'PersonaParameters'):
return Persona(objtId, p.name(), p.activities(), p.attitudes(),
p.aptitudes(), p.motivations(),
p.skills(), p.intrinsic(), p.contextual(), p.image(),
p.assumption(), p.type(), p.tags(),
p.environmentProperties(), p.codes())
if (p.__class__.__name__ == 'AssetParameters'):
return Asset(objtId, p.name(), p.shortCode(), p.description(),
p.significance(), p.type(), p.critical(),
p.criticalRationale(), p.tags(), p.interfaces(),
p.environmentProperties())
if (p.__class__.__name__ == 'TemplateAssetParameters'):
return TemplateAsset(objtId, p.name(), p.shortCode(), p.description(),
p.significance(), p.type(), p.surfaceType(),
p.accessRight(), p.properties(), p.rationale(),
p.tags(), p.interfaces())
if (p.__class__.__name__ == 'TemplateRequirementParameters'):
return TemplateRequirement(objtId, p.name(), p.asset(), p.type(),
p.description(), p.rationale(),
p.fitCriterion())
if (p.__class__.__name__ == 'TemplateGoalParameters'):
return TemplateGoal(objtId, p.name(), p.definition(), p.rationale(),
p.concerns(), p.responsibilities())
if (p.__class__.__name__ == 'SecurityPatternParameters'):
return SecurityPattern(objtId, p.name(), p.context(), p.problem(),
p.solution(), p.requirements(),
p.associations())
if (p.__class__.__name__ == 'ComponentParameters'):
return Component(objtId, p.name(), p.description(), p.interfaces(),
p.structure(), p.requirements(), p.goals(),
p.associations())
if (p.__class__.__name__ == 'ComponentViewParameters'):
return ComponentView(objtId, p.name(), p.synopsis(), p.components(),
p.connectors(), p.attackSurfaceMetric())
if (p.__class__.__name__ == 'ValueTypeParameters'):
return ValueType(objtId, p.name(), p.description(), p.type(),
p.score(), p.rationale())
if (p.__class__.__name__ == 'ClassAssociationParameters'):
return ClassAssociation(objtId, p.environment(), p.headAsset(),
p.headDimension(), p.headNavigation(),
p.headType(), p.headMultiplicity(),
p.headRole(), p.tailRole(),
p.tailMultiplicity(), p.tailType(),
p.tailNavigation(), p.tailDimension(),
p.tailAsset(), p.rationale())
if (p.__class__.__name__ == 'GoalAssociationParameters'):
return GoalAssociation(objtId, p.environment(), p.goal(),
p.goalDimension(), p.type(), p.subGoal(),
p.subGoalDimension(), p.alternative(),
p.rationale())
if (p.__class__.__name__ == 'DependencyParameters'):
return Dependency(objtId, p.environment(), p.depender(), p.dependee(),
p.dependencyType(), p.dependency(), p.rationale())
if (p.__class__.__name__ == 'GoalParameters'):
return Goal(objtId, p.name(), p.originator(), p.tags(),
p.environmentProperties())
if (p.__class__.__name__ == 'ObstacleParameters'):
return Obstacle(objtId, p.name(), p.originator(), p.tags(),
p.environmentProperties())
if (p.__class__.__name__ == 'DomainPropertyParameters'):
return DomainProperty(objtId, p.name(), p.description(), p.type(),
p.originator(), p.tags())
if (p.__class__.__name__ == 'ThreatParameters'):
return Threat(objtId, p.name(), p.type(), p.method(), p.tags(),
p.environmentProperties())
if (p.__class__.__name__ == 'VulnerabilityParameters'):
return Vulnerability(objtId, p.name(), p.description(), p.type(),
p.tags(), p.environmentProperties())
if (p.__class__.__name__ == 'RiskParameters'):
return Risk(objtId, p.name(), p.threat(), p.vulnerability(), p.tags(),
p.misuseCase())
if (p.__class__.__name__ == 'ResponseParameters'):
return Response(objtId, p.name(), p.risk(), p.tags(),
p.environmentProperties(), p.responseType())
if (p.__class__.__name__ == 'CountermeasureParameters'):
return Countermeasure(objtId, p.name(), p.description(), p.type(),
p.tags(), p.environmentProperties())
if (p.__class__.__name__ == 'TaskParameters'):
return Task(objtId, p.name(), p.shortCode(), p.objective(),
p.assumption(), p.author(), p.tags(),
p.environmentProperties())
if (p.__class__.__name__ == 'UseCaseParameters'):
return UseCase(objtId, p.name(), p.author(), p.code(), p.actors(),
p.description(), p.tags(), p.environmentProperties())
if (p.__class__.__name__ == 'MisuseCaseParameters'):
return MisuseCase(objtId, p.name(), p.environmentProperties(),
p.risk())
if (p.__class__.__name__ == 'DotTraceParameters'):
return DotTrace(p.fromObject(), p.fromName(), p.toObject(), p.toName())
if (p.__class__.__name__ == 'EnvironmentParameters'):
return Environment(objtId, p.name(), p.shortCode(), p.description(),
p.environments(), p.duplicateProperty(),
p.overridingEnvironment(), p.tensions())
if (p.__class__.__name__ == 'RoleParameters'):
return Role(objtId, p.name(), p.type(), p.shortCode(), p.description(),
p.environmentProperties())
if (p.__class__.__name__ == 'ResponsibilityParameters'):
return Responsibility(objtId, p.name())
if (p.__class__.__name__ == 'ExternalDocumentParameters'):
return ExternalDocument(objtId, p.name(), p.version(), p.date(),
p.authors(), p.description())
if (p.__class__.__name__ == 'InternalDocumentParameters'):
return InternalDocument(objtId, p.name(), p.description(), p.content(),
p.codes(), p.memos())
if (p.__class__.__name__ == 'CodeParameters'):
return Code(objtId, p.name(), p.type(), p.description(),
p.inclusionCriteria(), p.example())
if (p.__class__.__name__ == 'MemoParameters'):
return Memo(objtId, p.name(), p.description())
if (p.__class__.__name__ == 'DocumentReferenceParameters'):
return DocumentReference(objtId, p.name(), p.document(),
p.contributor(), p.description())
if (p.__class__.__name__ == 'ConceptReferenceParameters'):
return ConceptReference(objtId, p.name(), p.dimension(),
p.objectName(), p.description())
if (p.__class__.__name__ == 'PersonaCharacteristicParameters'):
return PersonaCharacteristic(objtId, p.persona(), p.qualifier(),
p.behaviouralVariable(),
p.characteristic(), p.grounds(),
p.warrant(), p.backing(), p.rebuttal())
if (p.__class__.__name__ == 'TaskCharacteristicParameters'):
return TaskCharacteristic(objtId, p.task(), p.qualifier(),
p.characteristic(), p.grounds(), p.warrant(),
p.backing(), p.rebuttal())
if (p.__class__.__name__ == 'ImpliedProcessParameters'):
return ImpliedProcess(objtId, p.name(), p.description(), p.persona(),
p.network(), p.specification(), p.channels())
if (p.__class__.__name__ == 'LocationsParameters'):
return Locations(objtId, p.name(), p.diagram(), p.locations(),
p.links())
else:
raise UnknownParameterClass(str(objtId))
def add_role(self, role_name):
role = Role(role_name)
roles[role_name] = role
return role
])
H = [[
np.random.rayleigh(np.sqrt(2 / np.pi) * math.pow(10, -3))
for y in range(number_of_edge)
] for x in range(number_of_user)]
d_cpu = np.array([
random.uniform(1.75, 2.75) * math.pow(10, 9)
for x in range(number_of_user)
])
network = np.array([
random.uniform(chs, chs) * math.pow(10, 6)
for x in range(number_of_edge)
])
player = Role(number_of_edge=number_of_edge,
number_of_user=number_of_user,
network=network,
cpu=cpu,
d_cpu=d_cpu,
H=H)
player.initial_DAG()
while t < I:
network = np.array(
[chs * math.pow(10, 6) for x in range(number_of_edge)])
for k in range(number_of_edge):
player.edges[k].bandwidth = network[k]
total, it, finish_hist1, bandwidth1, opt_delta1, selection1, finished, energy, local, improvement = test(
1,
False,
model=1,
epsilon=epsilon,
number_of_user=number_of_user,
number_of_edge=number_of_edge,
def test_role():
r = Role(10000, 20000)
print str(r)
r.rem_health(100)
print str(r)
r.add_health(200)
print r
print r.is_alive()
r.rem_health(10000)
print r.is_alive()
from Server import Server
from Role import Role
Roles = {} # empty dictionary
Servers = {} # empty dictionary
a = Role("db", [], [])
Roles["db"] = Role("db", ["install mysql", "install mysql_client"],
["configure iptable"])
Roles["web"] = Role("web", ["install apache", "install php"],
["configure iptable", "configure iptables"])
Servers["Server1"] = Server("Server1", "db")
Servers["server2"] = Server("Server2", "web")
Servers["server3"] = Server("Server3", "web")
def buildServers(pServers, pRoles):
for k, v in pServers.items():
role = pRoles[v.get_role()]
print(v.get_name())
for c in role.get_commands():
print(c)
for ip in role.get_iptables():
print(ip)
buildServers(Servers, Roles)
def __init__(self, name, description=None, superRoles=[]):
Role.__init__(self, name, description)
for role in superRoles:
assert isinstance(role, Role)
self._superRoles = superRoles[:]
class RoleTests(CairisTests):
# region Class fields
logger = logging.getLogger(__name__)
existing_role_id = 122
existing_role_name = 'Certificate Authority'
role_class = Role.__module__ + '.' + Role.__name__
new_role = Role(roleId=-1,
roleName='Student',
rType='Stakeholder',
sCode='STU',
roleDesc='This is a test role',
cProps=[])
new_role_props = [
RoleEnvironmentProperties(
environmentName='Core Technology',
responses=[('Prevent Unauthorised Certificate Access', 'High')],
countermeasures=['Location-based X.509 extension'])
]
new_role_dict = {
'session_id': 'test',
'object': new_role,
'property_0': new_role_props
}
new_role_body = jsonpickle.encode(new_role_dict)
# endregion
logger.info('JSON data: %s', new_role_body)
def test_get_all(self):
method = 'test_get_all'
rv = self.app.get('/api/roles?session_id=test')
roles = json_deserialize(rv.data)
self.assertIsNotNone(roles, 'No results after deserialization')
self.assertIsInstance(roles, dict,
'The result is not a dictionary as expected')
self.assertGreater(len(roles), 0, 'No roles in the dictionary')
self.assertIsInstance(roles.values()[0], Role)
self.logger.info('[%s] Roles found: %d', method, len(roles))
self.logger.info('[%s] First role: %s [%d]\n', method,
roles.values()[0].theName,
roles.values()[0].theId)
def test_post(self):
method = 'test_post_new'
rv = self.app.post('/api/roles',
content_type='application/json',
data=self.new_role_body)
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
role_id = json_resp.get('role_id', None)
self.assertIsNotNone(role_id, 'No role ID returned')
self.logger.info('[%s] Role ID: %d', method, role_id)
rv = self.app.get('/api/roles/id/%d?session_id=test' % role_id)
role = jsonpickle.decode(rv.data)
self.logger.info('[%s] Role: %s [%d]\n', method, role['theName'],
role['theId'])
def test_get_id(self):
method = 'test_get_id'
url = '/api/roles/id/%d?session_id=test' % self.existing_role_id
self.logger.info('[%s] URL: %s', method, url)
rv = self.app.get(url)
self.assertIsNotNone(rv.data, 'No response')
self.logger.debug('[%s] Response data: %s', method, rv.data)
role = jsonpickle.decode(rv.data)
self.assertIsNotNone(role, 'No results after deserialization')
self.assertEqual(role['__python_obj__'], self.role_class,
'The result is not an role as expected')
self.logger.info('[%s] Role: %s [%d]\n', method, role['theName'],
role['theId'])
def test_get_name(self):
method = 'test_get_name'
url = '/api/roles/name/%s?session_id=test' % quote(
self.existing_role_name)
rv = self.app.get(url)
role = json_deserialize(rv.data)
self.assertIsNotNone(role, 'No results after deserialization')
self.assertIsInstance(role, Role,
'The result is not an role as expected')
self.logger.info('[%s] Role: %s [%d]\n', method, role.theName,
role.theId)
def test_put_name(self):
method = 'test_put_name'
url = '/api/roles/name/%s' % quote(self.new_role.theName)
upd_role = self.new_role
upd_role.theName = 'Test3'
upd_role_dict = self.new_role_dict
upd_role_dict['object'] = upd_role
upd_role_body = jsonpickle.encode(upd_role_dict)
self.logger.info('[%s] JSON data: %s', method, upd_role_body)
rv = self.app.put(url,
content_type='application/json',
data=upd_role_body)
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
message = json_resp.get('message', None)
self.assertIsNotNone(message, 'No message returned')
rv = self.app.get('/api/roles/name/Test3?session_id=test')
role = json_deserialize(rv.data)
self.logger.info('[%s] Role: %s [%d]\n', method, role.theName,
role.theId)
def test_put_id(self):
method = 'test_put_id'
rv = self.app.get('/api/roles?session_id=test')
roles = json_deserialize(rv.data)
role = roles.get(self.new_role.theName)
url = '/api/roles/id/%d' % role.theId
upd_role = self.new_role
upd_role.theName = 'Test2'
upd_role_dict = self.new_role_dict
upd_role_dict['object'] = upd_role
upd_role_body = jsonpickle.encode(upd_role_dict)
self.logger.info('[%s] JSON data: %s', method, upd_role_body)
rv = self.app.put(url,
content_type='application/json',
data=upd_role_body)
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
message = json_resp.get('message', None)
self.assertIsNotNone(message, 'No message returned')
rv = self.app.get('/api/roles/name/Test2?session_id=test')
role = json_deserialize(rv.data)
self.logger.info('[%s] Role: %s [%d]\n', method, role.theName,
role.theId)
def test_x_delete_name(self):
method = 'test_delete_name'
url = '/api/roles/name/{}?session_id=test'.format(
quote(self.new_role.theName))
rv = self.app.delete(url)
self.logger.debug('[%s] Response data: %s', method, rv.data)
json_resp = json_deserialize(rv.data)
self.assertIsNotNone(json_resp, 'No results after deserialization')
message = json_resp.get('message', None)
self.assertIsNotNone(message, 'No message returned')
self.logger.info('[%s] Message: %s\n', method, message)
url = '/api/roles/name/Test2?session_id=test'.format(
quote(self.new_role.theName))
rv = self.app.delete(url)
url = '/api/roles/name/Test3?session_id=test'.format(
quote(self.new_role.theName))
rv = self.app.delete(url)
def test_get_props_name_get(self):
method = 'test_get_props_name_get'
url = '/api/roles/name/%s/properties?session_id=test' % quote(
self.existing_role_name)
cls_role_prop = RoleEnvironmentProperties.__module__ + '.' + RoleEnvironmentProperties.__name__
rv = self.app.get(url)
role_props = jsonpickle.decode(rv.data)
self.assertIsNotNone(role_props, 'No results after deserialization')
self.assertGreater(len(role_props), 0,
'List does not contain any elements')
role_prop = role_props[0]
self.assertEqual(cls_role_prop, role_prop['__python_obj__'],
'The result is not an role as expected')
self.logger.info('[%s] Role property: %s\n', method,
role_props[0]['theEnvironmentName'])
if __name__ == '__main__':
"""
*******************
Creating Resources
*******************
"""
emails = Resource("Emails")
text_messages = Resource("Text Messages")
account_details = Resource("Account Details")
"""
*******************
Creating Roles
*******************
"""
role_read_emails = Role("Role Read Emails").add_resource_privileges(
emails, [ActionType.READ])
role_emails = Role("Role Emails").add_resource_privileges(
emails, [ActionType.READ, ActionType.WRITE, ActionType.DELETE])
role_read_messages = Role("Role Read Messages").add_resource_privileges(
text_messages, [ActionType.READ])
role_messages = Role("Role Messages").add_resource_privileges(
text_messages, [ActionType.READ, ActionType.WRITE, ActionType.DELETE])
role_read_account_details = Role(
"Role Read Account Details").add_resource_privileges(
account_details, [
ActionType.READ,
])
role_account_details = Role(
"Role Account Details").add_resource_privileges(
def test_1_create_role(self):
repo = RoleRepository()
r1 = Role(rolename=ROLENAME)
r1.permissions = ['Berechtigung 1', 'Berechtigung 2', 'Berechtigung 3']
role = repo.create_role(r1)
self.assertEqual(role.rolename, ROLENAME)
# 3, 40， 85
# 3, 35, 101
# 3, 30, 85, 87, 72
number_of_user, number_of_edge, epsilon = 18, 3, 0.001
chs = 10
t = 0
#f = 1.25
number_of_chs = np.array([random.randint(8, 12) for x in range(number_of_edge)])
cpu = np.array([random.uniform(4, 6) * math.pow(10, 9) for x in range(number_of_edge)])
H = [[np.random.rayleigh(np.sqrt(2 / np.pi) * math.pow(10, -3)) for y in range(number_of_edge)] for x in
range(number_of_user)]
#H = [[0.0015828476479607767], [0.001915567718048535], [0.0014273299132096429], [0.0004296867113777556],
# [0.001195544533603154], [0.0009713295589935165], [0.00042464050995390663], [0.0015832283722535597]]
d_cpu = np.array([random.uniform(1.5, 2.5) * math.pow(10, 9) for x in range(number_of_user)])
player = Role(number_of_edge=number_of_edge, number_of_user=number_of_user, epsilon=epsilon,
number_of_chs=number_of_chs, cpu=cpu, d_cpu=d_cpu, H=H)
player.initial_DAG()
#player.initial_config_DAG()
print("H=", H)
while t < I:
#number_of_chs = np.array([random.randint(16, 24) for x in range(number_of_edge)])
for k in range(number_of_edge):
player.edges[k].freq = cpu[k]
cpu[k] += math.pow(10, 9)
it1, finish_hist1, bandwidth1, opt_delta1, selection1, finished1, energy1, local, improvement1 \
= test(1, False, channel_allocation=1, epsilon=epsilon, number_of_user=number_of_user, number_of_edge=number_of_edge
,player=copy.deepcopy(player))
print(bandwidth1)
it2, finish_hist2, bandwidth2, opt_delta2, selection2, finished2, energy2, local, improvement2 \
= test(1, True, channel_allocation=1, epsilon=epsilon, number_of_user=number_of_user, number_of_edge=number_of_edge
,player=copy.deepcopy(player))
def __init__(self, name, description=None, superRoles=[]):
Role.__init__(self, name, description)
for role in superRoles:
if not isinstance(role, Role):
raise TypeError('%s is not a Role object' % (role,))
self._superRoles = superRoles[:]
def initRole():
global role
roleName = input('您好，请输入您的名字：')
print('初始化玩家...')
role = Role(roleName)
def __init__(self, name, description=None, superRoles=[]): Role.__init__(self, name, description) for role in superRoles: assert isinstance(role, Role) self._superRoles = superRoles[:]
ALIGNMENT_MAFIA_2KP2 = Alignment(name="Mafia",
win_con="Parity",
night_action="2 kp till 2")
ALIGNMENT_MAFIA = Alignment(name="Mafia",
win_con="Parity",
night_action="1 kp")
MEDIC = Medic(name="Medic", active_n0=True, heal_self=False)
ONESHOTVIGI = Vigi(name="One Shot Vigi", active_n0=True, charges=1)
ONESHOTVIGINON0 = Vigi(name="One Shot Vigi", active_n0=False, charges=1)
COP = Cop(name="Full Alignment Cop", active_n0=True, target_self=False)
SMART_HUNTER_VEN = Smart_Hunter_Ven(name="Smart Hunter")
INNOCENT_CHILD = Innocent_Child(name="Inno Child")
POSSUM = Possum(name="Possum")
VANILLA_TOWN = Role(name="Vanilla Town", active_n0=False)
MAFIA_GOON = Role(name="Mafia Goon", active_n0=False)
STRATEGY_DEFAULT = Strategy.DefaultStrategy(
name="Default Strategy",
description="Target random, always activate and claim")
STRATEGY_ACTIVATEN1 = VigiStratSimpleActivation(
name="Simple Activation",
description="Activate on certain nights",
when_to_activate=["n1"])
STRAT_SMARTVIGIN2 = VigiStratSmartActivation(
name="Smart Activation",
description="Activate if known mafia or if deadline reached",
when_to_activate=[])
def init_models():
Role.create_base_role()
add_administrator_user()
TimeSpan.add_default_timespan()
return lambda: f"You dont have {action_type} permission on resource {resource}"
return wrapper
return check_permissions_decorator
print('-----ROLE BASED AUTH CONTROL SYSTEM-----')
# creating admin role
admin_permissions = [
action + '$' + resource for action in ACTION_TYPES
for resource in SAMPLE_RESOURCES
]
# print(admin_permissions)
admin_role = Role('admin_role', admin_permissions)
ROLES_MAP[admin_role.role_name] = admin_role
#creat read role
# read_role = Role('read_role', ['read$user'])
# ROLES_MAP[read_role.role_name] = read_role
# create admin user
admin_user = User('admin_user', [
admin_role,
])
USERS_MAP[admin_user.name] = admin_user
CURRENT_USER = admin_user
def init_models():
Role.create_base_role()
add_administrator_user()
TimeSpan.add_default_timespan()
def test_1_create_role(self):
repo = RoleRepository()
r1 = Role(rolename=ROLENAME)
r1.permissions = ['Berechtigung 1', 'Berechtigung 2', 'Berechtigung 3']
role = repo.create_role(r1)
self.assertEqual(role.rolename, ROLENAME)
async def handle_new_role(self, message):
role = Role(message)
await role.create_role()
role_message = RoleMessage(role.role)
await role_message.send_role_message("", self.roles_channel)