def update(id, _org_label, _prj_label, _payload):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
view = nxs.views.fetch(org_label=_org_label, project_label=_prj_label, view_id=id)
view_md5_before = utils.generate_nexus_payload_checksum(view, debug=True)
current_revision = view["_rev"]
if _payload is not None:
view = json.loads(_payload)
else:
# If no payload given, load up the entry in a text file and open default editor
new_file, filename = tempfile.mkstemp()
print("Opening an editor: %s" % filename)
f = open(filename, "w")
f.write(json.dumps(view, indent=2))
f.close()
click.edit(filename=filename)
f = open(filename, "r")
view = json.loads(f.read())
f.close()
os.remove(filename)
view_md5_after = utils.generate_nexus_payload_checksum(view, debug=True)
if view_md5_before == view_md5_after:
print("No change in view, aborting update.")
else:
nxs.views.update_es(esview=view, rev=current_revision)
print("View updated.")
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def _list(_from, size, _json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.organizations.list(pagination_from=_from,
pagination_size=size)
if _json:
utils.print_json(response, colorize=pretty)
else:
table = PrettyTable(['Label', 'Description', 'Id', 'Deprecated'])
table.align["Label"] = "l"
table.align["Description"] = "l"
table.align["Id"] = "l"
table.align["Deprecated"] = "l"
for r in response["_results"]:
if "description" in r:
table.add_row([
r["_label"], r["description"], r["@id"],
r["_deprecated"]
])
else:
table.add_row(
[r["_label"], "", r["@id"], r["_deprecated"]])
print(table)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def show_identities(_json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.identities.fetch()
if _json:
utils.print_json(response, colorize=pretty)
else:
columns = ["Id", "Type", "Realm", "User", "Group"]
table = PrettyTable(columns)
for c in columns:
table.align[c] = "l"
for i in response["identities"]:
realm = ""
if "realm" in i:
realm = i["realm"]
user = ""
if "subject" in i:
user = i["subject"]
group = ""
if "group" in i:
realm = i["group"]
table.add_row([i["@id"], i["@type"], realm, user, group])
print(table)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def view_token():
"""Show token for current profile."""
config = utils.get_cli_config()
_token = None
selected = None
for key in config.keys():
if nexuscli.config.SELECTED_KEY in config[key] and config[key][
nexuscli.config.SELECTED_KEY] is True:
selected = key
if TOKEN_KEY in config[key]:
_token = config[key][TOKEN_KEY]
print(_token)
decoded = jwt.decode(_token, verify=False)
print("\nDecoded token:")
utils.print_json(decoded, colorize=True)
expiry_utc = datetime.utcfromtimestamp(decoded['exp'])
expires_in = expiry_utc.timestamp() - datetime.now().timestamp(
)
if expires_in > 0:
when = "in %s" % utils.print_time(expires_in)
message_color = 'green'
else:
when = "%s ago" % utils.print_time(abs(expires_in))
message_color = 'red'
msg = "\nExpiry: %s (%s)" % (
utils.datetime_from_utc_to_local(expiry_utc), when)
click.echo(click.style(msg, fg=message_color))
if _token is None:
if selected is None:
utils.error("You haven't selected a profile.")
else:
utils.error('No tokens in selected profile: %s' % selected)
def _list(_org_label, _prj_label, deprecated, _from, size, _type, _json,
pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
response = nxs.views.list(org_label=_org_label,
project_label=_prj_label,
pagination_from=_from,
pagination_size=size,
deprecated=deprecated,
type=_type)
if _json:
utils.print_json(response, colorize=pretty)
else:
table = PrettyTable(['Id', 'Type', 'Revision', 'Deprecated'])
table.align["Id"] = "l"
table.align["Type"] = "l"
table.align["Revision"] = "l"
table.align["Deprecated"] = "l"
for r in response["_results"]:
types = utils.format_json_field(r, "@type")
table.add_row([r["@id"], types, r["_rev"], r["_deprecated"]])
print(table)
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def query_sparql(_org_label, _prj_label, id, _payload, file, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
default_query = "SELECT * WHERE { ?s ?p ?o } LIMIT 10"
data = get_query_from_payload_xor_data_otherwise_editor(
_payload, file, default_query, file_prefix="query-sparql")
response = nxs.views.query_sparql(org_label=_org_label,
project_label=_prj_label,
query=data,
view_id=id)
if _json:
utils.print_json(response, colorize=pretty)
else:
vars = response["head"]["vars"]
table = PrettyTable(vars)
for v in vars:
table.align[v] = "l"
for b in response["results"]["bindings"]:
cells = []
for v in vars:
cells.append(b[v]["value"])
table.add_row(cells)
print(table)
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def create(_org_label, _prj_label, id, file, _type, _payload, format, idcolumn, idnamespace, mergewith, mergeon, max_connections, schema, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
data = {}
if _payload is not None and file is not None:
utils.error("--data and --file are mutually exclusive.")
if _payload is not None:
data = json.loads(_payload)
if file is not None:
if format == "json":
with open(file) as f:
data = json.load(f)
if len(data) == 0:
utils.error("You must give a non empty payload")
response = nxs.resources.create(org_label=_org_label, project_label=_prj_label, data=data,
schema_id=schema, resource_id=id)
print("Resource created (id: %s)" % response["@id"])
if _json:
utils.print_json(response, colorize=pretty)
elif format == "csv":
utils.load_csv(_org_label, _prj_label, schema, file_path=file, merge_with=mergewith, merge_on=mergeon, _type=_type, id_colum=idcolumn, id_namespace=idnamespace, max_connections=max_connections)
print("Finished loading.")
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def update(id, _org_label, _prj_label, _payload):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
data = nxs.resources.fetch(org_label=_org_label, project_label=_prj_label, schema_id='_', resource_id=id)
data_md5_before = utils.generate_nexus_payload_checksum(data)
current_revision = data["_rev"]
if _payload is not None:
data = json.loads(_payload)
else:
# If no payload given, load up the entry in a text file and open default editor
new_file, filename = tempfile.mkstemp()
print("Opening an editor: %s" % filename)
f = open(filename, "w")
f.write(json.dumps(data, indent=2))
f.close()
click.edit(filename=filename)
f = open(filename, "r")
data = json.loads(f.read())
f.close()
os.remove(filename)
data_md5_after = utils.generate_nexus_payload_checksum(data)
if data_md5_before == data_md5_after:
print("No change in resource, aborting update.")
else:
nxs.resources.update(resource=data, rev=current_revision)
print("Resource updated.")
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def create(label, _org_label, description, base, vocab, _api_mapping, _json,
pretty):
_org_label = utils.get_organization_label(_org_label)
try:
mappings = None
if _api_mapping is not None:
mappings = []
for am in _api_mapping:
if "=" not in am:
utils.error(
"Invalid API Mapping, it should be in the format <prefix>=<URL>: %s"
% am)
key, value = am.split("=", 1)
entry = {"prefix": key, "namespace": value}
mappings.append(entry)
nxs = utils.get_nexus_client()
response = nxs.projects.create(org_label=_org_label,
project_label=label,
description=description,
api_mappings=mappings,
vocab=vocab,
base=base)
print("Project created (id: %s)" % response["@id"])
if _json:
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def make_public(_org_label, _prj_label, _replace, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
path = _org_label + '/' + _prj_label
utils.warn("You are about to make the data in your project public to the world.")
input("Press <ENTER> to continue, CTRL+C to cancel...")
response = nxs.acls.fetch(subpath=path)
count = len(response["_results"])
if count > 1:
utils.error("More than one ACL matching: %d" % count)
elif count == 0:
utils.warn("No ACL found specifically for this organization '%s' and project '%s'." % (_org_label, _prj_label))
current_rev = 0
else:
current_rev = response["_results"][0]['_rev']
_identities = [_ANONYMOUS_]
_permissions = [_PROJECTS_READ_, _RESOURCES_READ_, _VIEWS_QUERY_]
if _replace:
print("Replacing existing ACLs on project '%s' in organization '%s'" % (_prj_label, _org_label))
response = nxs.acls.replace(subpath=path, identities=_identities, permissions=[_permissions],
rev=current_rev)
else:
print("Adding to existing ACLs on project '%s' in organization '%s'" % (_prj_label, _org_label))
response = nxs.acls.append(subpath=path, identities=_identities, permissions=[_permissions],
rev=current_rev)
if _json:
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def create(_org_label, _prj_label, id, _projects, _identities, _priority,
_resources_types, _type, _payload, file, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
data = {}
if _payload is not None and file is not None:
utils.error("--data and --file are mutually exclusive.")
if _priority is not None and _identities is not None and _projects is not None:
response = nxs.resolvers.create(org_label=_org_label,
project_label=_prj_label,
projects=_projects,
identities=_identities,
_priority=_priority,
_id=id,
resources_types=_resources_types)
else:
if _payload is not None:
data = json.loads(_payload)
if file is not None:
with open(file) as f:
data = json.load(f)
if len(data) == 0:
utils.error(
"The provided file %s should contain a non empty json payload"
% file)
if not data:
# If no payload given, load up the entry in a text file and open default editor
new_file, filename = tempfile.mkstemp()
print("Opening an editor: %s" % filename)
f = open(filename, "w")
f.write(json.dumps(data, indent=2))
f.close()
click.edit(filename=filename)
f = open(filename, "r")
data = json.loads(f.read())
f.close()
os.remove(filename)
if data:
full_url = nexussdk_http._full_url(
path=[nxs.resolvers.SEGMENT, _org_label, _prj_label],
use_base=False)
response = nxs.resolvers.create_(path=full_url,
payload=data,
id=id)
else:
utils.error(
"--data, --file or (--priority, --identities, --projects) are required for creating a resolver."
)
print("Resolver created (id: %s)" % response["@id"])
if _json:
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def fetch(label, revision, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.realms.fetch(label, revision)
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
print(e.response.json())
utils.error(str(e))
def update(label, data, _json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.realms.replace_(label, data, data['_rev'])
if _json:
utils.print_json(response, colorize=pretty)
utils.success("Realm updated.")
except nxs.HTTPError as e:
print(e.response.json())
utils.error(str(e))
def create(label, name, _open_id_config, logo, _json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.realms.create(label, name, _open_id_config, logo)
if _json:
utils.print_json(response, colorize=pretty)
utils.success("Realm created.")
except nxs.HTTPError as e:
print(e.response.json())
utils.error(str(e))
def _list():
nxs = utils.get_nexus_client()
try:
response = nxs.realms.list()
utils.print_json(response, colorize=True)
for r in response["_results"]:
print(r["name"], r["_deprecated"])
except nxs.HTTPError as e:
print(e.response.json())
utils.error(str(e))
def fetch(label, revision, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.organizations.fetch(org_label=label, rev=revision)
if revision is not None and response["_rev"] != revision:
utils.error("Revision '%s' does not exist" % revision)
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def fetch(id, _org_label, _prj_label, schema, revision, tag, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
response = nxs.resources.fetch(org_label=_org_label, project_label=_prj_label, schema_id=schema,
resource_id=id, rev=revision, tag=tag)
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def _list(_org_label, _prj_label, deprecated, _from, size, search, _json,
pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
response = nxs.schemas.list(org_label=_org_label,
project_label=_prj_label,
pagination_from=_from,
pagination_size=size,
deprecated=deprecated,
full_text_search_query=search)
if _json:
utils.print_json(response, colorize=pretty)
else:
columns = [
'Id', 'Types', 'Label', 'Imports', 'NodeShapes',
'PropertyShapes', 'Revision', 'Deprecated'
]
table = PrettyTable(columns)
for c in columns:
table.align[c] = "l"
for r in response["_results"]:
types = utils.format_json_field(r, "@type")
# Get extra info from the schema itself
schema = nxs.schemas.fetch(org_label=_org_label,
project_label=_prj_label,
schema_id=r["@id"])
imports = utils.format_json_field(schema, "imports")
node_shapes = get_shapes_id_by_node_kind(
schema, ["sh:NodeShape", "NodeShape"])
property_shapes = get_shapes_id_by_node_kind(
schema, ["sh:PropertyShapes", "PropertyShapes"])
dummy_payload = {
"nodes": node_shapes,
"properties": property_shapes
}
nodes = utils.format_json_field(dummy_payload, "nodes")
properties = utils.format_json_field(dummy_payload,
"properties")
label = ""
if "label" in schema:
label = schema["label"]
table.add_row([
r["@id"], types, label, imports, nodes, properties,
r["_rev"], r["_deprecated"]
])
print(table)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def deprecate(label, _json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.realms.deprecate(label)
if _json:
utils.print_json(response, colorize=pretty)
utils.success("Realm deprecated.")
except nxs.HTTPError as e:
print(e.response.json())
utils.error(str(e))
def select(label, _json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.realms.fetch(label)
if _json:
utils.print_json(response, colorize=pretty)
utils.set_default_realm(label, response['_issuer'])
utils.success("Realm selected.")
except nxs.HTTPError as e:
print(e.response.json())
utils.error(str(e))
def create(label, description, _json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.organizations.create(org_label=label,
description=description)
print("Organization created (id: %s)" % response["@id"])
if _json:
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def statistics(_org_label, _prj_label, id, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
response = nxs.views.stats(org_label=_org_label,
project_label=_prj_label,
view_id=id)
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def update(id, _org_label, _prj_label, _projects, _identities, _priority,
_resources_types, _type, _payload):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
data = nxs.resolvers.fetch(org_label=_org_label,
project_label=_prj_label,
id=id)
current_revision = data["_rev"]
data_md5_before = utils.generate_nexus_payload_checksum(data)
if _priority is not None and _identities is not None and _projects is not None:
response = nxs.resolvers.update(org_label=_org_label,
project_label=_prj_label,
projects=_projects,
identities=_identities,
_priority=_priority,
id=id,
rev=current_revision,
resources_types=_resources_types)
else:
if _payload is not None:
data = json.loads(_payload)
else:
# If no payload given, load up the entry in a text file and open default editor
new_file, filename = tempfile.mkstemp()
print("Opening an editor: %s" % filename)
f = open(filename, "w")
f.write(json.dumps(data, indent=2))
f.close()
click.edit(filename=filename)
f = open(filename, "r")
data = json.loads(f.read())
f.close()
os.remove(filename)
data_md5_after = utils.generate_nexus_payload_checksum(data)
if data_md5_before == data_md5_after:
print("No change in resolver, aborting update.")
else:
encoded_id = encode_url(id)
nxs.resolvers.update_(path=[
nxs.resolvers.SEGMENT, _org_label, _prj_label, encoded_id
],
payload=data,
rev=current_revision)
print("Resolver updated.")
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def select(label):
nxs = utils.get_nexus_client()
try:
nxs.organizations.fetch(org_label=label)
except nxs.HTTPError as e:
if e.response.status_code == 404:
utils.error("Could not find organization with label '%s'." % label)
else:
# unexpected error
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
utils.set_default_organization(label)
print("organization selected.")
def show_permissions(_json, pretty):
nxs = utils.get_nexus_client()
try:
response = nxs.permissions.fetch()
if _json:
utils.print_json(response, colorize=pretty)
else:
table = PrettyTable(['Permissions'])
table.align['Permissions'] = "l"
for p in response["permissions"]:
table.add_row([p])
print(table)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def select(label, _org_label):
_org_label = utils.get_organization_label(_org_label)
try:
nxs = utils.get_nexus_client()
nxs.projects.fetch(org_label=_org_label, project_label=label)
except nxs.HTTPError as e:
if e.response.status_code == 404:
utils.error("Could not find project with label '%s' under organization '%s'." % (label, _org_label))
else:
# unexpected error
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
utils.set_default_project(label)
print("Project selected.")
def create(_org_label, _prj_label, id, _payload, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
data = {}
if _payload is not None:
data = json.loads(_payload)
response = nxs.views.create_es(org_label=_org_label, project_label=_prj_label, view_data=data, view_id=id)
print("View created (id: %s)" % response["@id"])
if _json:
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def create(_org_label, _prj_label, id, _payload, file, dir, _schemas_base_dir,
_schemas_ns, _strategy, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
data = {}
if _payload is not None and file is not None:
utils.error("--data and --file are mutually exclusive.")
if _payload is not None:
data = json.loads(_payload)
if file is not None:
with open(file) as f:
data = json.load(f)
if dir is not None:
if _schemas_base_dir:
print(_schemas_base_dir)
_schemas_base_dir = json.loads(_schemas_base_dir)
imported, not_imported = schemahelper.import_schemas(
dir, _org_label, _prj_label, _schemas_base_dir, _schemas_ns,
_strategy)
if len(not_imported) > 0:
with open("schema-import-errors.log", "w") as file:
for (schema_file_path, exception_name,
error_message) in not_imported:
file.write(
"schema={} exception_name={} message={}\n".format(
schema_file_path, exception_name,
error_message))
utils.error(
"\nFailed to import {} schemas. See 'schema-import-errors.log' for details."
.format(len(not_imported)))
if data:
response = nxs.schemas.create(org_label=_org_label,
project_label=_prj_label,
schema_obj=data,
schema_id=id)
print("Schema created (id: %s)" % response["@id"])
if _json:
utils.print_json(response, colorize=pretty)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))
def query_es(_org_label, _prj_label, id, _payload, file, _json, pretty):
_org_label = utils.get_organization_label(_org_label)
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
default_query = {"query": {"query_string": {"query": "*"}}}
data = get_query_from_payload_xor_data_otherwise_editor(
_payload, file, default_query, file_prefix="query-es")
response = nxs.views.query_es(org_label=_org_label,
project_label=_prj_label,
view_id=id,
query=data)
if _json:
utils.print_json(response, colorize=pretty)
else:
table = PrettyTable(['Id', 'Type', 'Revision', 'Deprecated'])
table.align["Id"] = "l"
table.align["Type"] = "l"
table.align["Revision"] = "l"
table.align["Deprecated"] = "l"
for r in response["hits"]["hits"]:
types = ""
if "_source" in r and "@type" in r["_source"]:
if type(r["_source"]["@type"]) is str:
types = r["_source"]["@type"]
elif isinstance(r["_source"]["@type"],
collections.Sequence):
for t in r["_source"]["@type"]:
types += t + "\n"
else:
utils.warn("Unsupported type: " +
type(r["_source"]["@type"]))
types = r["_source"]["@type"]
else:
types = '-'
table.add_row([
r["_source"]["@id"], types, r["_source"]["_rev"],
r["_source"]["_deprecated"]
])
print(table)
except nxs.HTTPError as e:
utils.error(str(e))
utils.print_json(e.response.json(), colorize=True)
def _list(_org_label, _prj_label, subpath, _ancestor, _self, _json, pretty, verbose):
if _org_label != '*':
_org_label = utils.get_organization_label(_org_label)
if _prj_label != '*':
_prj_label = utils.get_project_label(_prj_label)
nxs = utils.get_nexus_client()
try:
path = _org_label + '/' + _prj_label
if subpath is not None:
path += '/' + subpath
if verbose:
print("subpath: %s" % path)
print("self: %s" % _self)
print("ancestors: %s" % _ancestor)
response = nxs.acls.list(subpath=path, ancestors=_ancestor, self=_self)
if _json:
utils.print_json(response, colorize=pretty)
else:
columns = ['Path', 'Identity', 'Permissions']
table = PrettyTable(columns)
for c in columns:
table.align[c] = "l"
for _acl in response["_results"]:
for entry in _acl["acl"]:
i = entry["identity"]
_type = i["@type"]
printed_identity = _type
if _type == "User":
printed_identity = "%s: %s (realm: %s)" % (_type, i["subject"], i["realm"])
elif _type == "Group":
printed_identity = "%s: %s (realm: %s)" % (_type, i["group"], i["realm"])
elif _type == "Authenticated":
printed_identity = "%s (realm: %s)" % (_type, i["realm"])
_permissions = "\n".join(entry["permissions"])
table.add_row([_acl["_path"], printed_identity, _permissions])
print(table)
except nxs.HTTPError as e:
utils.print_json(e.response.json(), colorize=True)
utils.error(str(e))