def app_init():
admin_role=Role("ADMIN")
user_role=Role("USER")
admin_role.add_resource("BACKEND_SERVER_CONFIG",["READ","WRITE","DELETE"])
admin_user=User("admin",[admin_role])
user=User("User1",[user_role])
def test_find_role(self):
r1 = Role("foo")
r2 = Role("Bar")
r3 = Role("Baz")
roles = [r1, r2, r3]
found_role = find_role(r2.name, roles)
assert_that([role.name for role in roles]).contains(found_role.name)
def test_req_num_emp_not_greater_than_minimum_task_req(self):
generic = CommonTestFunctions()
category = generic.category()
location = generic.location()
group = generic.group()
duration1 = generic.duration(6, 7)
duration2 = generic.duration(7, 8)
duration3 = generic.duration(8, 9)
task1 = generic.task(group,
location,
category,
duration1,
required_number_of_employees=2,
id=1)
task2 = generic.task(group,
location,
category,
duration2,
required_number_of_employees=4,
id=2)
task3 = generic.task(group,
location,
category,
duration3,
required_number_of_employees=3,
id=3)
tasks = [
task1,
task2,
task3,
]
acceptable = [
1,
2,
]
unacceptable = [
3,
4,
5,
]
for a in acceptable:
Role(1, 'Role', tasks, a)
for u in unacceptable:
try:
Role(1, 'Role', tasks, u)
except AssertionError:
pass
else:
raise Exception(
'Creating a role with a bad req number of employees did not raise an exception. '
+ str(u))
def add(self, ico_name, ico_token, ico_url, role_name):
duplicate = self.__find_duplicate(ico_url)
if duplicate is not None:
self.__add_role_to_ico(duplicate, Role(role_name))
else:
roles = []
roles.append(Role(role_name))
ico = Ico(ico_name, ico_token, ico_url)
self.positions.append((ico, roles))
def add_role(self, role_json):
""" Append Role object to list """
if not ("role" in role_json):
print("Error: File format error. Missing 'role' in json array.")
exit(100)
if "inherits" in role_json:
self.list.append(Role(role_json["role"], role_json["inherits"]))
else:
self.list.append(Role(role_json["role"]))
def repo_all_roles(account_number, commit=False):
"""
Repo all eligible roles in an account. Collect any errors and display them at the end.
Args:
account_number (string)
commit (bool): actually make the changes
Returns:
None
"""
errors = []
role_ids_in_account = roledata.role_ids_for_account(account_number)
roles = Roles([])
for role_id in role_ids_in_account:
roles.append(
Role(roledata.get_role_data(role_id),
fields=['Active', 'RoleName']))
roles = roles.filter(active=True)
for role in roles:
errors.append(repo_role(account_number, role.role_name, commit=commit))
if errors:
LOGGER.error('Error(s) during repo: \n{}'.format(errors))
else:
LOGGER.info('Everything successful!')
def test_assign_role_with_bad_time(self):
generic = CommonTestFunctions()
category = generic.category()
location = generic.location()
group = generic.group()
duration1 = generic.duration(6, 7)
duration2 = generic.duration(7, 8)
duration3 = generic.duration(8, 9)
task1 = generic.task(group, location, category, duration1, required_number_of_employees=4, id=1)
task2 = generic.task(group, location, category, duration2, required_number_of_employees=4, id=2)
task3 = generic.task(group, location, category, duration3, required_number_of_employees=3, id=3)
tasks = [
task1,
task2,
task3,
]
role = Role(1, 'Role1', tasks, 3)
availability = [generic.availability(6,8)]
groups = [group]
preferences = [generic.preference(category)]
staff_member = generic.staff_member(availability=availability, preferences=preferences, groups=groups, id=1)
self.assertRaises(BadRoleAssignmentException, staff_member.assign_role, role)
self.assertFalse(staff_member.has_role(role))
self.assertFalse(staff_member.can_assign_role(role))
self.assertFalse(staff_member.has_role(role))
self.assertFalse(staff_member.try_assign_role(role))
self.assertFalse(staff_member.has_role(role))
def get_membership(self, user_id=None, role=Role('member'),
group_id=None):
"""Search for user group membership, of a certain role.
user_id -- if unspecified default to current_user_dn
role -- Role
group_id -- if specified search only for this group
"""
if not user_id:
user_id = self.current_user_dn
url = self.base_url + "/search?"
params = {'ID': user_id,
'IDTYPE': 'x500',
'ROLE': role.get_name()}
if group_id:
params['GROUPID'] = group_id
xml_string = self._download_xml(url, params=params)
reader = GroupsReader()
groups = reader.read(xml_string)
self.logger.info('Retrieved groups ' + ', '.join([g.group_id for g in groups]))
return groups
def addDefaultRoles(self):
for name, groupName in cfg.DEFAULT_ROLES[self.platoon_size].items():
# Only add role if the group exists
if groupName in self.roleGroups.keys():
emoji = self.normalEmojis[name]
newRole = Role(name, emoji, False)
self.roleGroups[groupName].addRole(newRole)
def fromJson(self, data: dict, emojis: Tuple[Emoji], manual_load=False):
self.name = data["name"]
if not manual_load:
self.isInline = data["isInline"]
roles: List[str] = []
for roleEmoji, roleData in data["roles"].items():
try:
roleEmoji = cfg.ADDITIONAL_ROLE_EMOJIS[int(roleEmoji)]
except ValueError:
for emoji in emojis:
if emoji.name == roleEmoji:
roleEmoji = emoji
break
if not manual_load:
# Only create new roles if we're not loading data manually from
# the command channel
role = Role(roleData["name"], roleEmoji,
self.get_corrected_name(roleData))
self.roles.append(role)
else:
try:
role = next(x for x in self.roles if x.emoji == roleEmoji)
except StopIteration:
name = roleData.get("show_name") or roleData["name"]
raise UnexpectedRole(
"Cannot import unexpected role '{}'".format(name))
roles.append(roleEmoji)
role.fromJson(roleData, manual_load=manual_load)
if manual_load:
# Remove roles that were not present in imported data
self.roles = [x for x in self.roles if x.emoji in roles]
def add_pair(self, member, role):
try:
self.stats[give_faction(role)] += 1
except KeyError:
pass
self.player_map[member] = Player(member, role)
self.role_map[role] = Role(role, self.player_map[member])
self.player_map[member].role_class = self.role_map[role]
def __init__(self, setting): #世界的生成，主角初始化
self.map = Map(setting)
self.state = State(setting)
self.me = Role(1, 1, '猪脚')
self.me.setting_attr(1, 1000)
self.me.check()
self.map.add(self.me)
self.should_add_time = 0
def __init__(self, level):
super(HowlGame, self).__init__(255, 255, 255, 255, 4000, 2000)
# init voice
self.NUM_SAMPLES = 1000 # pyAudio内部缓存块大小
self.LEVEL = 1500 # 声音保存的阈值
self.sample_count = 0 # 取样次数
self.average_volume = 0 # 平均音量
# init floor
self.floor = Floor(self, level)
self.add(self.floor, 0)
# init voiceBar
self.voiceBar = Sprite('ground/black.png', color=(0, 0, 255))
# self.voiceBar.position = 100, 460
self.voiceBar.scale_y = 0.1
self.voiceBar.image_anchor = 0, 0
self.add(self.voiceBar, 1)
# init role
self.role = Role(self)
self.role_run_to_right = False
self.role_run_to_left = False
self.add(self.role, 2)
self.action = FadeOut(0.5)
# init monster
# self.monster_node = cocos.cocosnode.CocosNode()
# for i in range(5):
# self.monster_node.add(Monster(self))
# self.add(self.monster_node)
# init flag
# flag = cocos.sprite.Sprite('scene/flag.png')
# flag.position = 3500, 120
# flag.scale = 0.5
# self.flag = flag
# self.add(flag)
# init stone
self.stone = None
self.boom = cocos.sprite.Sprite('scene/boom.png')
# init gameoverlayer
self.gameover = None
# Open Audio Input
pa = PyAudio()
SAMPLING_RATE = int(
pa.get_device_info_by_index(0)['defaultSampleRate'])
self.stream = pa.open(format=paInt16,
channels=1,
rate=SAMPLING_RATE,
input=True,
frames_per_buffer=self.NUM_SAMPLES)
self.schedule(self.update)
def create_base_tables():
"""Cria as tabelas base e prenche os valores iniciais!"""
import objs
from base_models import Sequence
model = Sequence()
syncModel(model)
#print('users')
from users import Users
model = Users()
syncModel(model)
#print('role')
from role import Role
model = Role()
syncModel(model)
result = Users().get()
if len(result) == 0:
import base64
password = base64.encodestring('noops!admin'.encode('utf-8')).decode('utf-8')
new_user_id = get_identity(table='users', user=None)
sql = "INSERT INTO users (nome, login, password, email, estado, id, user_create, date_create, active) VALUES ('admin', 'admin', '{var1}', 'admin@localhost', 'active','{var2}','{var3}','{var4}', True);".format(var1=password,var2= new_user_id, var3=new_user_id, var4=str(datetime.datetime.today()))
#print(sql)
with getcursor() as cursor:
cursor.execute(sql)
result = Role().get()
if len(result) == 0:
new_role_id = get_identity(table='role', user=new_user_id)
sql = "INSERT INTO role (nome, id, user_create, date_create, active) VALUES ('Administrator', '{var1}','{var2}','{var3}', True);".format(var1=new_role_id, var2=new_role_id, var3=str(datetime.datetime.today()))
#print(sql)
with getcursor() as cursor:
cursor.execute(sql)
#sql = 'CREATE TABLE IF NOT EXISTS role_users (id VARCHAR(50) PRIMARY KEY, role INTEGER, user_id INTEGER);'
#with getcursor() as cursor:
# cursor.execute(sql)
new_id = get_identity(table='role_users', user=new_user_id)
sql = "INSERT INTO role_users (role, users, id) VALUES ('{var1}','{var2}','{var3}');".format(var1=new_role_id, var2=new_user_id, var3=new_id)
#print(sql)
with getcursor() as cursor:
cursor.execute(sql)
def role(self,
tasks,
required_number_of_employees=1,
name='Role',
id=None):
if id == None:
id = self._get_next_role_id()
r = Role(id, name, tasks, required_number_of_employees)
self.created_roles.append(r)
return r
def main(argv):
ota = AWS_IoT_OTA()
ota_bucket = S3Bucket(args.s3bucket, args.region)
if (False == ota_bucket.exists()):
if (True == ota_bucket.create()): print("Created bucket")
else:
sys.exit()
ota_role = Role(args.role)
if (False == ota_role.exists()):
ota_role.init_role_policies(account_id=args.account,
bucket_name=args.s3bucket)
ota.DoUpdate()
def test_cannot_give_conflicting_tasks(self):
generic = CommonTestFunctions()
required_number_of_employees = 1
category = generic.category()
location = generic.location()
group = generic.group()
duration1 = generic.duration(6, 7)
duration2 = generic.duration(7, 8)
duration3 = generic.duration(8, 9)
duration4 = generic.duration(6, 8)
task1 = generic.task(
group,
location,
category,
duration1,
required_number_of_employees=required_number_of_employees,
id=1)
task2 = generic.task(
group,
location,
category,
duration2,
required_number_of_employees=required_number_of_employees,
id=2)
task3 = generic.task(
group,
location,
category,
duration3,
required_number_of_employees=required_number_of_employees,
id=3)
task4 = generic.task(
group,
location,
category,
duration4,
required_number_of_employees=required_number_of_employees,
id=4)
tasks = [task1, task2, task3, task4]
role = None
try:
role = Role(1, 'Role', tasks, required_number_of_employees)
except AssertionError:
pass
else:
raise Exception(
'Creating the role did not raise a conflicting task exception.'
)
def delete_all_config(self):
if 'C_CONFIG_LAMBDAPROXY' in self.vars:
if self.config.has_section(self.vars['C_CONFIG_LAMBDAPROXY']):
for lp in self.config.items(self.vars['C_CONFIG_LAMBDAPROXY']):
self = Ltklambdaproxy(self, lp[0]).undeploy_lambda_proxy()
if 'C_CONFIG_SQS_QUEUES' in self.vars and 'C_CONFIG_SQS' in self.vars:
queues = Utils.get_list_config(self, self.vars['C_CONFIG_SQS'],
self.vars['C_CONFIG_SQS_QUEUES'])
for q in queues:
self = Queue(self, q).delete_queue()
self = Role(self, "bypassvalidator").unset_default_role()
def addAdditionalRole(self, name: str) -> str:
# Find next emoji for additional role
if self.countReactions() >= MAX_REACTIONS:
raise RoleError("Too many roles, not adding role {}".format(name))
emoji = cfg.ADDITIONAL_ROLE_EMOJIS[self.additionalRoleCount]
# Create role
newRole = Role(name, emoji, True)
# Add role to additional roles
self.roleGroups["Additional"].addRole(newRole)
self.additionalRoleCount += 1
return emoji
def parse_roles_and_users(roles_filepath: str, users_filepath: str):
"""
Parse the input json to Roles and Users
:param roles_filepath: The file location of the input roles file
:type roles_filepath: str
:param users_filepath: The file location of the input users file
:type users_filepath: str
:return: A tuple of dictionaries (roles and users)
"""
roles_input = json_parser(roles_filepath, 'roles')
users_input = json_parser(users_filepath, 'users')
roles = {
r["Id"]: Role(r["Id"], r["Name"], r["Parent"])
for r in roles_input
}
users = {u["Id"]: User(u["Id"], u["Name"], u["Role"]) for u in users_input}
# Attach parents to roles
for k, current_role in roles.items():
parent_role_id = current_role.parent_id
# Try to fetch the parent role
try:
parent_role = roles[parent_role_id]
# Add child roles
parent_role.add_child_role(current_role)
# Add parent role. This is redundant with a simpler child role reference
# current_role.set_parent_role(parent_role)
except KeyError as e:
# If parent can't be found, it must be a root role
logging.info(f"RoleID {current_role.id} is the root role")
current_role.set_as_root_role()
# Set roles to users
for k, current_user in users.items():
role_id = current_user.role_id
try:
current_user.set_role(roles[role_id])
except:
logging.warning(f"Unable to set role {role_id} to {current_user}")
return (roles, users)
def find_roles_with_permission(permission):
"""
Search roles in all accounts for a policy with a given permission, log the ARN of each role with this permission
Args:
permission (string): The name of the permission to find
Returns:
None
"""
for roleID in roledata.role_ids_for_all_accounts():
role = Role(
roledata.get_role_data(roleID,
fields=['Policies', 'RoleName', 'Arn']))
permissions = roledata._get_role_permissions(role)
if permission.lower() in permissions:
LOGGER.info('ARN {arn} has {permission}'.format(
arn=role.arn, permission=permission))
def display_roles(account_number, inactive=False):
"""
Display a table with data about all roles in an account and write a csv file with the data.
Args:
account_number (string)
inactive (bool): show roles that have historically (but not currently) existed in the account if True
Returns:
None
"""
headers = [
'Name', 'Refreshed', 'Disqualified By', 'Can be repoed', 'Permissions',
'Repoable', 'Repoed', 'Services'
]
rows = list()
roles = Roles([
Role(roledata.get_role_data(roleID))
for roleID in tqdm(roledata.role_ids_for_account(account_number))
])
if not inactive:
roles = roles.filter(active=True)
for role in roles:
rows.append([
role.role_name, role.refreshed, role.disqualified_by,
len(role.disqualified_by) == 0, role.total_permissions,
role.repoable_permissions, role.repoed, role.repoable_services
])
rows = sorted(rows, key=lambda x: (x[5], x[0], x[4]))
rows.insert(0, headers)
# print tabulate(rows, headers=headers)
t.view(rows)
with open('table.csv', 'wb') as csvfile:
csv_writer = csv.writer(csvfile)
csv_writer.writerow(headers)
for row in rows:
csv_writer.writerow(row)
def __init__(self):
self.iChat = ChatFeatures()
self.iChat.process()
self.linkFeatsDayUser = self.iChat.linkAnalysis()
self.domainWordsDayUser = self.iChat.domainWordsPerDay()
self.msgPerTurnDayUser = self.iChat.msgPerTurn()
self.quranCitesDayUser = self.iChat.quranCites()
self.iTopic = Topic()
#generalRelevance[date] = score
self.generalRelevanceDay = self.iTopic.relevantDayDetection()
self.userRelevanceDay = {}
for user in self.iChat.userSet:
self.userRelevanceDay[user] = self.iTopic.relevantDayDetection(
"./stats/distances" + user[0].upper() + user[1:] + ".tsv")
self.iRole = Role()
self.roleScoresDayUser = self.iRole.computeRolesPerDay()
self.wordsPerDayUser = self.iChat.wordsPerDay()
def test_assign_role(self):
generic = CommonTestFunctions()
category = generic.category()
location = generic.location()
group = generic.group()
duration1 = generic.duration(6, 7)
duration2 = generic.duration(7, 8)
duration3 = generic.duration(8, 9)
task1 = generic.task(group, location, category, duration1, required_number_of_employees=4, id=1)
task2 = generic.task(group, location, category, duration2, required_number_of_employees=4, id=2)
task3 = generic.task(group, location, category, duration3, required_number_of_employees=3, id=3)
tasks = [
task1,
task2,
task3,
]
required_number_of_employees = 3
role = Role(1, 'Role', tasks, required_number_of_employees)
availability = [generic.availability(6,22)] # Yes
groups = [group]
preferences = [generic.preference(category)]
staff_member = generic.staff_member(availability=availability, preferences=preferences, groups=groups, id=1)
self.assertFalse(staff_member.has_role(role))
try:
staff_member.assign_role(role)
except BadRoleAssignmentException as e:
self.fail('There was an exception while trying to assign a task to the member. Additional info: ' + str(e.args))
self.assertTrue(staff_member.has_role(role))
for task in role.tasks:
self.assertTrue(staff_member.has_task(task))
def loginF(role):
flag = True
print('当前角色编码是%s' % role)
while flag:
exits = 0
user = input('用户：')
password = input('密码：')
f = open('../db/user.txt', 'r')
data = f.readlines()
print('用户数据：', data)
for i in data:
i = i.replace('\n', '').split(' ')
#print('校验密码',i[0],i[1],i[2])
#print('校验密码', user, password, role)
if i[0] == user and i[1] == password and i[2] == role:
exits = 1
if exits == 1:
print('用户校验成功！')
r = Role(role, user)
r.selectType()
else:
print('用户名或密码错误！')
def test_task(self):
generic = CommonTestFunctions()
required_number_of_employees = 1
category = generic.category()
location = generic.location()
group = generic.group()
duration1 = generic.duration(6, 7)
duration2 = generic.duration(7, 8)
duration3 = generic.duration(8, 9)
task1 = generic.task(
group,
location,
category,
duration1,
required_number_of_employees=required_number_of_employees,
id=1)
task2 = generic.task(
group,
location,
category,
duration2,
required_number_of_employees=required_number_of_employees,
id=2)
task3 = generic.task(
group,
location,
category,
duration3,
required_number_of_employees=required_number_of_employees,
id=3)
tasks = [task1, task2, task3]
role = Role(1, 'Role', tasks, 1)
self.assertEqual(role.tasks[0], tasks[0])
self.assertEqual(role.tasks[1], tasks[1])
self.assertEqual(role.tasks[2], tasks[2])
def addAdditionalRole(self, name: str) -> str:
# check if this role already exists
for roleGroup in self.roleGroups.values():
role: Role
for role in roleGroup.roles:
if role.name == name:
raise RoleError(f"Role with name {name} already exists, "
"not adding new role")
# Find next emoji for additional role
if self.countReactions() >= MAX_REACTIONS:
raise RoleError("Too many roles, not adding role {}".format(name))
emoji = cfg.ADDITIONAL_ROLE_EMOJIS[self.additionalRoleCount]
# Create role
newRole = Role(name, emoji, True)
# Add role to additional roles
self.roleGroups["Additional"].addRole(newRole)
self.additionalRoleCount += 1
return emoji
def is_member(self, group_ids, user_id=None, role=Role('member')):
""" Return True if user_id is a member (type of role) of at
least one group in group_ids. False otherwise.
group_ids -- list of group ID strings
user_id -- if unspecified default to x509_dn
role -- Role
"""
# Allow the caller to supply a single string
if isinstance(group_ids, str):
group_ids = [group_ids]
if not user_id:
user_id = self.current_user_dn
# get_membership returns a single-element set if member of a
# particular group. Stop as soon as we find one.
for group in group_ids:
if self.get_membership(group_id=group, user_id=user_id,
role=role):
return True
return False
def create_role (self, role_type, player):
"""Creates a new role representing a role in this association.
:param role_type: the role type
:type role_type: `Topic`
:param player: the role player
:type player: `Topic`
:rtype: `Role`
"""
if role_type is None:
raise ModelConstraintException(self, 'The type may not be None')
if player is None:
raise ModelConstraintException(self, 'The player may not be None')
if self.topic_map != role_type.topic_map:
raise ModelConstraintException(
self, 'The type is not from the same topic map')
if self.topic_map != player.topic_map:
raise ModelConstraintException(
self, 'The player is not from the same topic map')
role = Role(association=self, type=role_type, player=player,
topic_map=self.topic_map)
role.save()
return role
def create_user():
user_name=input("Enter user name: ")
print("Roles available: ")
for role in ROLE_TYPES:
print(role)
role_types=input("Enter roles (space separated): ").split(" ")
for role_type in role_types:
if not is_valid_role_type(role_type):
print("Invalid role type provided , please try again! ")
create_user()
roles=[]
role_found=False
for role_type in role_types:
for existing_role in ROLES:
if role_type==existing_role.role_type:
role=existing_role
role_found=True
break
if role_found==False:
role=Role(role_type)
roles.append(role)
new_user=User(user_name,roles)
