def _sync_site_groups(self): self.logger.debug('Revision groups on site') ad_site_groups = [ g.name.value for g in self.ad.get_site_groups(self.site_name) ] tableau_site_groups = [g.name for g in TSC.Pager(self.tab.groups)] new_groups = set(ad_site_groups) - set(tableau_site_groups) old_groups = set(tableau_site_groups) - set(ad_site_groups) old_groups.remove('All Users') # This ugly code, but I was forced to write this. if self.site_name == 'ERS': self.logger.info(f"Site ERS. Remove from old_groups F_* and A_*") old_groups = [ t for t in old_groups if not (t.startswith('F_') or t.startswith('A_')) ] # End ugly code if new_groups: self.logger.info("New groups {0}".format(new_groups)) if old_groups: self.logger.info("Old groups {0}".format(old_groups)) for group in new_groups: new_group = TSC.GroupItem(group) self.logger.info(f"Creating group {group}") if self.noop: self.tab.groups.create(new_group) for group in old_groups: group_id = [ g.id for g in TSC.Pager(self.tab.groups) if g.name == group ].pop() self.logger.info(f"Removing group {group}") if self.noop: self.tab.groups.delete(group_id)
def _clear_site_from_user(self, ignore_tag, user_id): self.lgr.debug( f'Run _clear_site_from_user with ignore_tag:{ignore_tag}, group_id:{user_id}' ) workbooks = [ w for w in list(TSC.Pager(self.tsc_server.workbooks)) if ignore_tag not in w.tags ] for w in workbooks: self.tsc_server.workbooks.populate_permissions(w) for p in w.permissions: if p.grantee.id == user_id and p.grantee.tag_name == 'user': self.lgr.info( f'Remove {str(p.capabilities)} permissions from wb: "{w.name}" , project: "{w.project_name})"' ) if not self.noop: self.tsc_server.workbooks.delete_permission(w, p) datasources = [ d for d in list(TSC.Pager(self.tsc_server.datasources)) if ignore_tag not in d.tags ] for d in datasources: self.tsc_server.datasources.populate_permissions(d) for p in d.permissions: if p.grantee.id == user_id and p.grantee.tag_name == 'user': self.lgr.info( f'Remove {str(p.capabilities)} permissions from datasource: "{d.name}" , project: "{d.project_name})"' ) if not self.noop: self.tsc_server.datasources.delete_permission(w, p)
def show_materialized_views_status(args, password, site_content_url): tableau_auth = TSC.TableauAuth(args.username, password, site_id=site_content_url) server = TSC.Server(args.server, use_server_version=True) enabled_sites = set() with server.auth.sign_in(tableau_auth): # For server admin, this will prints all the materialized views enabled sites # For other users, this only prints the status of the site they belong to print("Materialized views is enabled on sites:") # only server admins can get all the sites in the server # other users can only get the site they are in for site in TSC.Pager(server.sites): if site.materialized_views_mode != "disable": enabled_sites.add(site) print("Site name: {}".format(site.name)) print('\n') print("Materialized views is enabled on workbooks:") # Individual workbooks can be enabled only when the sites they belong to are enabled too for site in enabled_sites: site_auth = TSC.TableauAuth(args.username, password, site.content_url) with server.auth.sign_in(site_auth): for workbook in TSC.Pager(server.workbooks): if workbook.materialized_views_config[ 'materialized_views_enabled']: print("Workbook: {} from site: {}".format( workbook.name, site.name))
def update_project(project, server, materialized_views_config): all_projects = list(TSC.Pager(server.projects)) project_ids = find_project_ids_to_update(all_projects, project) for workbook in TSC.Pager(server.workbooks): if workbook.project_id in project_ids: workbook.materialized_views_config = materialized_views_config server.workbooks.update(workbook) print("Updated materialized views settings for project: {}".format( project.name)) print('\n')
def _sync_site_memberships(self): self.logger.debug('Revision group members on site') tableau_groups = [g for g in TSC.Pager(self.tab.groups)] opts = TSC.RequestOptions(pagesize=1000) # This ugly code, but I was forced to write this. if self.site_name == 'ERS': self.logger.info( "Site ERS. Remove from tableau_groups F_* and A_*") tableau_groups = [ t for t in tableau_groups if not (t.name.startswith('F_') or t.name.startswith('A_')) ] # End ugly code tableau_site_users = [u for u in TSC.Pager(self.tab.users)] for group in [g for g in tableau_groups if g.name != 'All Users']: self.tab.groups.populate_users(group, opts) tableau_members_set = set([user.name for user in group.users]) ad_members = self.ad.get_members_by_groupname(group.name) ad_members_set = set([u.sAMAccountName.value for u in ad_members]) new_members_set = ad_members_set - tableau_members_set old_members_set = tableau_members_set - ad_members_set if new_members_set: self.logger.info("{0}, new members:{1} ".format( group.name, new_members_set)) if old_members_set: self.logger.info("{0}, old members{1}".format( group.name, old_members_set)) for new_member in new_members_set: self.logger.info(f"Adding {new_member} to {group.name}") user_id = [ user.id for user in tableau_site_users if user.name == new_member ] if user_id: if self.noop: self.tab.groups.add_user(user_id=user_id.pop(), group_item=group) else: self.logger.warning( f"Can't add {new_member} to {group.name}. User not found" ) for old_member in old_members_set: self.logger.info(f"Removing {old_member} to {group.name}") user_id = [ user.id for user in tableau_site_users if user.name == old_member ].pop() if self.noop: self.tab.groups.remove_user(user_id=user_id, group_item=group)
def update_project_by_path(args, materialized_views_config, password, site_content_url): if args.project_path is None: print( "Use --project_path <project path> to specify the path of the project" ) return False tableau_auth = TSC.TableauAuth(args.username, password, site_content_url) server = TSC.Server(args.server, use_server_version=True) project_name = args.project_path.split('/')[-1] with server.auth.sign_in(tableau_auth): if not assert_site_enabled_for_materialized_views( server, site_content_url): return False projects = [ project for project in TSC.Pager(server.projects) if project.name == project_name ] if not assert_project_valid(args.project_path, projects): return False possible_paths = get_project_paths(server, projects) update_project(possible_paths[args.project_path], server, materialized_views_config) return True
def publish_to_server(site_name, server_address, project_name, tdsx_name, tableau_token_name, tableau_token): '''Publishes updated, local .tdsx to Tableau, overwriting the original file.''' # Creates the auth object based on the config file. tableau_auth = TSC.PersonalAccessTokenAuth( token_name=tableau_token_name, personal_access_token=tableau_token, site_id=site_name) server = TSC.Server(server_address) print(f"Signing into to site: {site_name}.") # Signs in and find the specified project. with server.auth.sign_in(tableau_auth): all_projects, pagination_item = server.projects.get() for project in TSC.Pager(server.projects): if project.name == project_name: project_id = project.id if project_id == None: message = "Could not find project. Please update the config file." sys.exit(message) print(f"Publishing to {project_name}.") # Publishes the data source. overwrite_true = TSC.Server.PublishMode.Overwrite datasource = TSC.DatasourceItem(project_id) file_path = os.path.join(os.getcwd(), tdsx_name) datasource = server.datasources.publish(datasource, file_path, overwrite_true) print(f"Publishing of datasource '{tdsx_name}' complete.")
def get_datasources(tableau_server, tableau_authentication): tableau_server.auth.sign_in(tableau_authentication) df = pd.DataFrame() for ds in TSC.Pager(tableau_server.datasources): ls = [[ ds.id, ds.name, ds.certified, ds.project_name, ds.datasource_type ]] df = df.append(pd.DataFrame( ls, columns=['id', 'name', 'cert', 'project', 'ds_type']), ignore_index=True) tableau_server.auth.sign_out() df = df[(df.ds_type == 'sqlserver') & (df.project == 'Datasource')] ds_to_remove = [ # tds that point to procs, not views 'New E&M Provider Clarity', 'Patient Trajectory Clarity', 'CFIM Charges', # embedded joins or custom sql; remove or recreate to use a view 'EBI_Call_Light (FI_DM_EBI)', 'Via Onc + Charges- Patient Level', 'Via Onc + Charges- Visit Level' ] for ds in ds_to_remove: df = df[df.name != ds] df = df.reset_index().drop(['index'], axis=1) return df.to_json()
def main(): parser = argparse.ArgumentParser(description='List out the names and LUIDs for different resource types') parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--site', '-S', default=None, help='site to log into, do not specify for default site') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--password', '-p', default=None, help='password for the user') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') parser.add_argument('resource_type', choices=['workbook', 'datasource', 'view']) args = parser.parse_args() if args.password is None: password = getpass.getpass("Password: ") else: password = args.password # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # SIGN IN tableau_auth = TSC.TableauAuth(args.username, password, args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { 'workbook': server.workbooks, 'datasource': server.datasources, 'view': server.views }.get(args.resource_type) for resource in TSC.Pager(endpoint.get): print(resource.id, resource.name, resource.content_url)
def publish_hyper(): """ Shows how to leverage the Tableau Server Client (TSC) to sign in and publish an extract directly to Tableau Online/Server """ # Sign in to server tableau_auth = TSC.PersonalAccessTokenAuth(token_name=token_name, personal_access_token=token_value, site_id=site_name) server = TSC.Server(server_address, use_server_version=True) print(f"Signing into {site_name} at {server_address}") with server.auth.sign_in(tableau_auth): # Define publish mode - Overwrite, Append, or CreateNew publish_mode = TSC.Server.PublishMode.Overwrite # Get project_id from project_name all_projects, pagination_item = server.projects.get() for project in TSC.Pager(server.projects): if project.name == project_name: project_id = project.id # Create the datasource object with the project_id datasource = TSC.DatasourceItem(project_id) print(f"Publishing {hyper_name} to {project_name}...") # Publish datasource datasource = server.datasources.publish(datasource, path_to_hyper, publish_mode) print("Datasource published. Datasource ID: {0}".format(datasource.id))
def extract_ds(server, project): datasources = {} for ds in TSC.Pager(server.datasources.get): if ds.project_name == project.name: server.datasources.populate_connections(ds) datasources[ds.name] = ds return datasources
def main(): parser = argparse.ArgumentParser(description='Cancel all of the running background jobs.') parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--site', '-S', default=None, help='site to log into, do not specify for default site') parser.add_argument('--username', '-u', required=True, help='username to sign into server') parser.add_argument('--password', '-p', default=None, help='password for the user') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') args = parser.parse_args() if args.password is None: password = getpass.getpass("Password: "******"progress", TSC.RequestOptions.Operator.LessThanOrEqual, 0)) for job in TSC.Pager(server.jobs, request_opts=req): print(server.jobs.cancel(job.id), job.id, job.status, job.type)
def create_webhook(token, event_type): tableau_auth = TSC.PersonalAccessTokenAuth(token_name=TABLEAU_TOKEN_NAME, personal_access_token=token, site_id=TABLEAU_SITE_NAME) server = TSC.Server(TABLEAU_SERVER) # Set http options to disable verifying SSL server.add_http_options({'verify': False}) server.use_server_version() with server.auth.sign_in_with_personal_access_token(tableau_auth): new_webhook = TSC.WebhookItem() new_webhook.name = "Webooks created from Heroku" new_webhook.url = HEROKU_URL new_webhook.event = event_type # Check if identical webhook is already created exists = False for existing_webhook in TSC.Pager(server.webhooks): exists = compare_webhook(new_webhook, existing_webhook) if exists: break if not exists: new_webhook = server.webhooks.create(new_webhook) print("Webhook created: {}".format(new_webhook)) return True, new_webhook else: print("Webhook already exists: {}".format(new_webhook)) return False, new_webhook
def main(): parser = argparse.ArgumentParser(description="Cancel all of the running background jobs.") # Common options; please keep those in sync across all samples parser.add_argument("--server", "-s", required=True, help="server address") parser.add_argument("--site", "-S", help="site name") parser.add_argument( "--token-name", "-p", required=True, help="name of the personal access token used to sign into the server" ) parser.add_argument( "--token-value", "-v", required=True, help="value of the personal access token used to sign into the server" ) parser.add_argument( "--logging-level", "-l", choices=["debug", "info", "error"], default="error", help="desired logging level (set to error by default)", ) # Options specific to this sample # This sample has no additional options, yet. If you add some, please add them here args = parser.parse_args() # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): req = TSC.RequestOptions() req.filter.add(TSC.Filter("progress", TSC.RequestOptions.Operator.LessThanOrEqual, 0)) for job in TSC.Pager(server.jobs, request_opts=req): print(server.jobs.cancel(job.id), job.id, job.status, job.type)
def update_workbook(args, materialized_views_config, password, site_content_url): if args.path_list is None and args.name_list is None: print( "Use '--path-list <filename>' or '--name-list <filename>' to specify the path of a list of workbooks" ) print('\n') return False tableau_auth = TSC.TableauAuth(args.username, password, site_id=site_content_url) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): if not assert_site_enabled_for_materialized_views( server, site_content_url): return False if args.path_list is not None: workbook_path_mapping = parse_workbook_path(args.path_list) all_projects = { project.id: project for project in TSC.Pager(server.projects) } update_workbooks_by_paths(all_projects, materialized_views_config, server, workbook_path_mapping) elif args.name_list is not None: update_workbooks_by_names(args.name_list, server, materialized_views_config) return True
def update_project_by_name(args, materialized_views_config, password, site_content_url): if args.project_name is None: print( "Use --project-name <project name> to specify the name of the project" ) return False tableau_auth = TSC.TableauAuth(args.username, password, site_content_url) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): if not assert_site_enabled_for_materialized_views( server, site_content_url): return False # get all projects with given name projects = [ project for project in TSC.Pager(server.projects) if project.name == args.project_name ] if not assert_project_valid(args.project_name, projects): return False if len(projects) > 1: possible_paths = get_project_paths(server, projects) print("Project name is not unique, use '--project_path <path>'") print("Possible project paths:") print_paths(possible_paths) print('\n') return False else: update_project(projects[0], server, materialized_views_config) return True
def test_pager_with_no_options(self): with open(GET_XML_PAGE1, "rb") as f: page_1 = f.read().decode("utf-8") with open(GET_XML_PAGE2, "rb") as f: page_2 = f.read().decode("utf-8") with open(GET_XML_PAGE3, "rb") as f: page_3 = f.read().decode("utf-8") with requests_mock.mock() as m: # Register Pager with default request options m.get(self.baseurl, text=page_1) # Register Pager with some pages m.get(self.baseurl + "?pageNumber=1&pageSize=1", text=page_1) m.get(self.baseurl + "?pageNumber=2&pageSize=1", text=page_2) m.get(self.baseurl + "?pageNumber=3&pageSize=1", text=page_3) # No options should get all 3 workbooks = list(TSC.Pager(self.server.workbooks)) self.assertTrue(len(workbooks) == 3) # Let's check that workbook items aren't duplicates wb1, wb2, wb3 = workbooks self.assertEqual(wb1.name, "Page1Workbook") self.assertEqual(wb2.name, "Page2Workbook") self.assertEqual(wb3.name, "Page3Workbook")
def load_workbooks(): """ :return: """ # authorize user tableau_auth = TSC.TableauAuth(config.username, config.password) # connect to server server = TSC.Server(config.server_name) with server.auth.sign_in(tableau_auth): for wb in TSC.Pager(server.workbooks): try: path = server.workbooks.download(wb.id, filepath=config.twb_path) # из коробки не сохраняет кирилицу - даём нормальное имя и на всякий случай удаляем расширение, # т.к. не всегда оно сохраняется и заменяем слеши wb_name = re.sub(r'\.twbx?', '', str(wb.name.encode('utf-8'))).replace('/', '\\') os.rename(path, '{}{}'.format(config.twb_path, wb_name)) # если отчёт скачался вместе с экстрактом - выпиливаем экстракт if zipfile.is_zipfile('{}{}'.format(config.twb_path, wb_name)): os.rename('{}{}'.format(config.twb_path, wb_name), '{}{}.twbx'.format(config.twb_path, wb_name)) else: os.rename('{}{}'.format(config.twb_path, wb_name), '{}{}.twb'.format(config.twb_path, wb_name)) except TSC.server.endpoint.exceptions.ServerResponseError: pass
def update_all_workbook_connections(self, curr_server_address, curr_username, new_server_address=None, new_server_port=None, new_username=None, new_password=None, new_embed_password: bool = None): log.info('Updating "%s" Connections! server :' % str(self.server.server_address)) for resource in TSC.Pager(self.server.workbooks): self.server.workbooks.populate_connections(resource) log.debug("Updating Connections for '%s' " % str(resource.name)) for conn in resource.connections: if conn.server_address == curr_server_address and conn.username == curr_username: log.info("Updating Connection " + str(conn)) if new_server_address is not None: conn.server_address = new_server_address if new_server_port is not None: conn.server_port = new_server_port if new_username is not None: conn.username = new_username if new_password is not None: conn.password = new_password if new_embed_password is not None: conn.embed_password = True self.server.workbooks.update_connection(resource, conn) log.info( 'Updated Connection of "%s" server_address:%s username:%s ' % (resource.name, curr_server_address, curr_username))
def site_details(event, context, server, site, sites, workbooks, all_users, unlicensed_users, unlicensed_usernames): print('Retrieving site information for {} '.format(server.site_id)) try: for wb in TSC.Pager(server.workbooks): workbooks.append(wb) users, _ = server.users.get() #for user in TSC.Pager(server.users): (this needs a fix to the tableauserverclient) for user in users: all_users.append(user) if user.site_role == 'Unlicensed': unlicensed_users.append(user) unlicensed_usernames.append({ 'name': user.name, 'site': site.name, 'site_role': user.site_role }) print(['{},{}'.format(user.site_role, user.name) for user in users]) for user in unlicensed_users: print(user.name) except: print(' Site information failed!') raise else: print(' Site information passed!') finally: print(' Site complete at {}'.format(str(datetime.now())))
def getSites(serverName): sites = [] try: # Step 1: Sign in to server. if args.si: tableau_auth = TSC.TableauAuth(args.u, password, site_id=args.si) else: tableau_auth = TSC.TableauAuth(args.u, password, site_id="") server = TSC.Server(serverName) server.add_http_options({'verify': False}) # The new endpoint was introduced in Version 2.4 server.version = APIVERSION with server.auth.sign_in(tableau_auth): # query the sites if args.si: sites.append(server.sites.get_by_name(args.si)) else: sites.extend(list(TSC.Pager(server.sites))) return sites except Exception as e: log.logger.error(f"{sys.exc_info()[0]}, {e}") os._exit(1) return False
def main(): parser = argparse.ArgumentParser(description='Demonstrate pagination on the list of workbooks on the server.') # Common options; please keep those in sync across all samples parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--site', '-S', help='site name') parser.add_argument('--token-name', '-n', required=True, help='name of the personal access token used to sign into the server') parser.add_argument('--token-value', '-v', required=True, help='value of the personal access token used to sign into the server') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') # Options specific to this sample # This sample has no additional options, yet. If you add some, please add them here args = parser.parse_args() # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # Sign in to server tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): # Pager returns a generator that yields one item at a time fetching # from Server only when necessary. Pager takes a server Endpoint as its # first parameter. It will call 'get' on that endpoint. To get workbooks # pass `server.workbooks`, to get users pass` server.users`, etc # You can then loop over the generator to get the objects one at a time # Here we print the workbook id for each workbook print("Your server contains the following workbooks:\n") for wb in TSC.Pager(server.workbooks): print(wb.name)
def main(): parser = argparse.ArgumentParser(description='List out the names and LUIDs for different resource types.') # Common options; please keep those in sync across all samples parser.add_argument('--server', '-s', required=True, help='server address') parser.add_argument('--site', '-S', help='site name') parser.add_argument('--token-name', '-n', required=True, help='name of the personal access token used to sign into the server') parser.add_argument('--token-value', '-v', required=True, help='value of the personal access token used to sign into the server') parser.add_argument('--logging-level', '-l', choices=['debug', 'info', 'error'], default='error', help='desired logging level (set to error by default)') # Options specific to this sample parser.add_argument('resource_type', choices=['workbook', 'datasource', 'project', 'view', 'job', 'webhooks']) args = parser.parse_args() # Set logging level based on user input, or error by default logging_level = getattr(logging, args.logging_level.upper()) logging.basicConfig(level=logging_level) # Sign in to server tableau_auth = TSC.PersonalAccessTokenAuth(args.token_name, args.token_value, site_id=args.site) server = TSC.Server(args.server, use_server_version=True) with server.auth.sign_in(tableau_auth): endpoint = { 'workbook': server.workbooks, 'datasource': server.datasources, 'view': server.views, 'job': server.jobs, 'project': server.projects, 'webhooks': server.webhooks, }.get(args.resource_type) for resource in TSC.Pager(endpoint.get): print(resource.id, resource.name)
def get_workbook_group(server, tableau_auth): with server.auth.sign_in(tableau_auth): all_workbooks_items, pagination_item = server.workbooks.get() abc = [] for workbook in all_workbooks_items: print(workbook.name) ds = server.workbooks.get_by_id(workbook.id) server.workbooks.populate_permissions(ds) permissions = ds.permissions i = -1 for rule in permissions: i += 1 group_user_type = permissions[i].grantee.tag_name group_user_id = permissions[i].grantee.id group_user_capabilities = permissions[i].capabilities if group_user_type == 'user': user_item = server.users.get_by_id( permissions[i].grantee.id) group_user_name = user_item.name elif group_user_type == 'group': for group_item in TSC.Pager(server.groups): if group_item.id == group_user_id: group_user_name = group_item.name break # print('Type: %s\tName: %s\tCapabilities: %s' %(group_user_type, group_user_name, group_user_capabilities)) abc.append([ workbook.name, group_user_type, group_user_name, group_user_capabilities ]) abc = pd.DataFrame(abc) abc.columns = [ 'workbook_name', 'group_type', 'user_name', 'capabilities' ] return abc
def list_workbook_ids(self, checkpoint: Union[datetime, str] = None, limit: int = None) -> List[str]: # Create client filter object req_option = tsc.RequestOptions() req_option.sort.add( tsc.Sort(tsc.RequestOptions.Field.UpdatedAt, tsc.RequestOptions.Direction.Asc)) if checkpoint: # Format datetime for filter if isinstance(checkpoint, datetime): cp = self.format_checkpoint_datetime(checkpoint) else: cp = self.format_checkpoint_datetime(parse(checkpoint)) req_option.filter.add( tsc.Filter(tsc.RequestOptions.Field.UpdatedAt, tsc.RequestOptions.Operator.GreaterThanOrEqual, cp)) # Get filtered id's server = self.server with server.auth.sign_in(self.authentication): workbook_ids = [ wb.id for wb in tsc.Pager(server.workbooks, req_option) ] else: # Get all workbook id's workbook_ids = self.list_all_workbook_ids() # Return, with optional applied limit if limit: return workbook_ids[:limit] else: return workbook_ids
def __get_flow_item(self, flow_name, project_name=None): item = None items_list = list() if not self.all_flows: self.all_flows = list(TSC.Pager(self.tsclient.flows)) for fl in self.all_flows: if project_name: if fl.project_name == project_name and fl.name == flow_name: item = fl else: if fl.name == flow_name: item = fl items_list.append(fl) if len(items_list) > 1: raise LookupError( f'More than one flow matched to: {flow_name}. Please specify Project Name for Distinct Match' ) if item: return item else: raise LookupError( f'Prep Flow with the specified name was not found: {flow_name}' )
def __get_datasource_item(self, datasource_name, project_name=None): item = None items_list = list() if not self.all_datasources: self.all_datasources = list(TSC.Pager(self.tsclient.datasources)) for ds in self.all_datasources: if project_name: if ds.project_name == project_name and ds.name == datasource_name: item = ds else: if ds.name == datasource_name: item = ds items_list.append(ds) if len(items_list) > 1: raise LookupError( f'More than one datasource matched to: {datasource_name}. Please specify Project Name for Distinct Match' ) if item: return item else: raise LookupError( f'Datasource with the specified name was not found: {datasource_name}' )
def __get_workbook_item(self, workbook_name, project_name=None): workbook_item = None items_list = list() if not self.all_workbooks: self.all_workbooks = list(TSC.Pager(self.tsclient.workbooks)) for wb in self.all_workbooks: if project_name: if wb.project_name == project_name and wb.name == workbook_name: workbook_item = wb else: if wb.name == workbook_name: workbook_item = wb items_list.append(wb) if len(items_list) > 1: raise LookupError( f'More than one workbook matched to: {workbook_name}. Please specify Project Name for Distinct Match' ) if workbook_item: return workbook_item else: raise LookupError( f'Workbook with the specified name was not found: {workbook_name}' )
def _get_group_id_by_name(self, name): groups = [ g.id for g in list(TSC.Pager(self.tsc_server.groups)) if g.name == name ] if groups: return groups.pop() return None
def _get_user_id_by_name(self, name): users = [ i.id for i in list(TSC.Pager(self.tsc_server.users)) if i.name == name ] if users: return users.pop() return None