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)