def _list_security_roles(
cls,
connection: "Connection",
to_dictionary: bool = False,
to_dataframe: bool = False,
limit: int = None,
**filters
) -> Union[List["SecurityRole"], List[Dict[str, Any]], DataFrame]:
if to_dictionary and to_dataframe:
helper.exception_handler(
"Please select either to_dictionary=True or to_dataframe=True, but not both.",
ValueError)
objects = helper.fetch_objects(
connection=connection,
api=security.get_security_roles,
limit=limit,
filters=filters,
)
if to_dictionary:
return objects
elif to_dataframe:
return DataFrame(objects)
else:
return [
cls.from_dict(source=obj, connection=connection)
for obj in objects
]
def list_privileges(cls, connection: Connection, to_dictionary: bool = False,
to_dataframe: bool = False,
**filters) -> Union[List["Privilege"], List[dict], DataFrame]:
"""Get list of privilege objects or privilege dicts. Filter the
privileges by specifying the `filters` keyword arguments.
Optionally use `to_dictionary` or `to_dataframe` to choose output
format.
Args:
connection: MicroStrategy connection object returned by
`connection.Connection()`.
to_dictionary: If `True` returns dict, by default (False) returns
User objects.
to_dataframe: If `True`, returns `DataFrame`.
**filters: Available filter parameters: ['id', 'name',
'description', 'categories', 'is_project_level_privilege']
Examples:
>>> Privilege.list_privileges(connection, to_dataframe=True,
>>> is_project_level_privilege='True',
>>> id=[1,2,3,4,5])
"""
if to_dictionary and to_dataframe:
helper.exception_handler(
"Please select either `to_dictionary=True` or `to_dataframe=True`, but not both.",
ValueError)
objects = helper.fetch_objects(connection=connection, api=security.get_privileges,
limit=None, filters=filters)
if to_dictionary:
return objects
elif to_dataframe:
return DataFrame(objects)
else:
return [cls.from_dict(source=obj, connection=connection) for obj in objects]
def _list_datasource_instances(
cls,
connection: "Connection",
to_dictionary: Optional[bool] = False,
limit: Optional[int] = None,
ids: Optional[list] = None,
database_types: Optional[list] = None,
project: Optional[Union["Project", str]] = None,
**filters) -> Union[List["DatasourceInstance"], List[dict]]:
objects = helper.fetch_objects(
connection=connection,
api=datasources.get_datasource_instances,
dict_unpack_value="datasources",
limit=limit,
filters=filters,
ids=ids,
database_types=database_types,
project=project)
if to_dictionary:
return objects
else:
return [
cls.from_dict(source=obj, connection=connection)
for obj in objects
]
def _list(cls,
connection: Connection,
default_connection_map: Optional[bool] = False,
project: Optional[Union[Project, str]] = None,
to_dictionary: bool = False,
limit: Optional[int] = None,
**filters) -> Union[List["DatasourceMap"], List[dict]]:
project_id = project.id if isinstance(project, Project) else project
try:
mappings = helper.fetch_objects(
connection=connection,
api=datasources.get_datasource_mappings,
default_connection_map=default_connection_map,
project_id=project_id,
limit=limit,
dict_unpack_value="mappings",
filters=filters)
except HTTPError as err:
if err.errno == 404:
if config.verbose:
logger.info('No mapping found.')
return None
else:
raise err
if to_dictionary:
return mappings
else:
return [
cls.from_dict(source=elem, connection=connection)
for elem in mappings
]
def list_schedules(connection: Connection,
to_dictionary: bool = False,
limit: int = None,
**filters) -> Union[List["Schedule"], List[dict]]:
"""List schedule objects or schedule dictionaries. Optionally filter list.
Args:
connection(object): MicroStrategy connection object returned by
'connection.Connection()'
to_dictionary(bool, optional): if True, return Schedules as
list of dicts
limit(int, optional): maximum number of schedules returned.
**filters: Available filter parameters:['name':,
'id',
'description',
'schedule_type',
'start_date',
'expired']
Returns:
Union[List["Schedule"], List[dict]]: [description]
"""
objects = helper.fetch_objects(connection=connection,
api=schedules.list_schedules,
limit=limit,
filters=filters,
dict_unpack_value='schedules')
if to_dictionary:
return objects
else:
return [
Schedule.from_dict(source=obj, connection=connection)
for obj in objects
]
def list_connections(self,
nodes: Union[str, List[str]] = None,
limit: Optional[int] = None,
**filters) -> List[Dict[str, Any]]:
"""Get all active database connections. Optionally filter the
connections by specifying the `filters` keyword arguments.
Args:
nodes: Node (server) names on which databases will be disconnected.
limit: limit the number of elements returned. If `None`, all objects
are returned.
**filters: Available filter parameters: ['status',
'database_instance_name', 'database_instance_id', 'user_name',
'database_login_name', 'cluster_node', 'id', 'name', 'type']
"""
if nodes is None:
all_nodes = Cluster(self.connection).list_nodes(to_dictionary=True)
nodes = [n['name'] for n in all_nodes if n['status'] == 'running']
nodes_names = ",".join(nodes) if isinstance(nodes, list) else nodes
all_databases = helper.fetch_objects(
connection=self.connection,
api=monitors.get_database_connections,
nodes_names=nodes_names,
dict_unpack_value="dbConnectionInstances",
limit=limit,
filters=filters)
return all_databases
def _list_contacts(cls, connection: 'Connection', to_dictionary: bool = False,
limit: Optional[int] = None, **filters
) -> Union[List['Contact'], List[dict]]:
"""Get all contacts as list of Contact objects or dictionaries.
Optionally filter the contacts by specifying filters.
Args:
connection: MicroStrategy connection object
to_dictionary: If True returns a list of contact dicts,
otherwise returns a list of contact objects
limit: limit the number of elements returned. If `None` (default),
all objects are returned.
**filters: Available filter parameters:
['id', 'name', 'description', 'enabled']
"""
objects = fetch_objects(
connection=connection,
api=contacts.get_contacts,
limit=limit,
filters=filters,
dict_unpack_value='contacts'
)
if to_dictionary:
return objects
return [
cls.from_dict(source=obj, connection=connection)
for obj in objects
]
def _list_available_dbms(cls,
connection: "Connection",
to_dictionary: bool = False,
limit: int = None,
**filters) -> Union[List["Dbms"], List[dict]]:
objects = helper.fetch_objects(connection=connection,
api=datasources.get_available_dbms,
limit=None,
filters=None)
cls._DBMS_CACHE.update([
cls.from_dict(source=obj, connection=connection) for obj in objects
])
if limit:
objects = objects[:limit]
if filters:
objects = helper.filter_list_of_dicts(objects, **filters)
if to_dictionary:
return objects
else:
return [
cls.from_dict(source=obj, connection=connection)
for obj in objects
]
def _list_datasource_logins(cls, connection: "Connection", to_dictionary: bool = False,
limit: int = None,
**filters) -> Union[List["DatasourceLogin"], List[dict]]:
objects = helper.fetch_objects(connection=connection,
api=datasources.get_datasource_logins,
dict_unpack_value="logins", limit=limit, filters=filters)
if to_dictionary:
return objects
else:
return [cls.from_dict(source=obj, connection=connection) for obj in objects]
def _list_devices(cls,
connection: "Connection",
to_dictionary: bool = False,
limit: int = None,
**filters) -> Union[List["Device"], List[dict]]:
objects = fetch_objects(
connection=connection,
api=devices.get_devices,
dict_unpack_value="devices",
limit=limit,
filters=filters,
)
if to_dictionary:
return objects
return [
cls.from_dict(source=obj, connection=connection) for obj in objects
]
def get_shortcuts(connection: Connection,
project_id: str,
shortcut_ids: List[str],
shortcut_info_flag: Union[
ShortcutInfoFlags,
int] = ShortcutInfoFlags.DssDossierShortcutInfoDefault,
to_dictionary: bool = False,
limit: Optional[int] = None,
**filters) -> Union[List[dict], List[Shortcut]]:
"""Retrieve information about specific published shortcuts
in specific project.
Args:
shortcut_ids: ids of target shortcuts
project_id: id of project that the shortcuts are in
shortcut_info_flag: a single ShortcutInfoFlags that describes what
exact info are to be fetched
to_dictionary: parameter describing output format
limit (int): limit the number of elements returned. If `None` (default),
all objects are returned.
Return:
list of dictionaries or Shortcut objects,
depending on `to_dictionary` parameter
"""
shortcuts = fetch_objects(
connection=connection,
api=browsing.get_shortcuts,
dict_unpack_value="shortcuts",
limit=limit,
filters=filters,
body=[{
"projectId": project_id,
"shortcutIds": shortcut_ids
}],
shortcut_info_flag=get_enum_val(shortcut_info_flag, ShortcutInfoFlags),
)
if to_dictionary:
return shortcuts
else:
return [
Shortcut.from_dict(source=short, connection=connection)
for short in shortcuts
]
def _list_transmitters(
cls,
connection: "Connection",
to_dictionary: bool = False,
limit: Optional[int] = None,
**filters) -> Union[List["Transmitter"], List[dict]]:
"""Helper method for listing transmitters."""
objects = fetch_objects(
connection=connection,
api=transmitters.get_transmitters,
limit=limit,
filters=filters,
dict_unpack_value="transmitters",
)
if to_dictionary:
return objects
return [
Transmitter.from_dict(source=obj, connection=connection)
for obj in objects
]
