def page(self):
if not self._attrs:
html.div(_("No custom attributes are defined yet."), class_="info")
return
with table_element(self._type + "attrs") as table:
for custom_attr in sorted(self._attrs, key=lambda x: x['title']):
table.row()
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link([
("mode", "edit_%s_attr" % self._type),
("edit", custom_attr['name'])
])
delete_url = make_confirm_link(
url=html.makeactionuri([("_delete", custom_attr['name'])]),
message=
_('Do you really want to delete the custom attribute "%s"?'
) % custom_attr['name'],
)
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(delete_url, _("Delete"), "delete")
table.text_cell(_("Name"), custom_attr['name'])
table.text_cell(_("Title"), custom_attr['title'])
table.cell(_("Type"),
dict(custom_attr_types())[custom_attr['type']])
def _show_tag_icons(self, tag_group, nr):
# Tag groups were made builtin with ~1.4. Previously users could modify
# these groups. These users now have the modified tag groups in their
# user configuration and should be able to cleanup this using the GUI
# for the moment. Make the buttons available to the users.
if self._builtin_config.tag_group_exists(
tag_group.id) and not self._tag_config.tag_group_exists(
tag_group.id):
html.i("(%s)" % _("builtin"))
return
edit_url = watolib.folder_preserving_link([("mode", "edit_tag"),
("edit", tag_group.id)])
html.icon_button(edit_url, _("Edit this tag group"), "edit")
html.element_dragger_url("tr",
base_url=make_action_link([("mode", "tags"),
("_move", nr)]))
delete_url = make_confirm_link(
url=make_action_link([("mode", "tags"),
("_delete", tag_group.id)]),
message=_("Do you really want to delete the tag group '%s'?") %
tag_group.id)
html.icon_button(delete_url, _("Delete this tag group"), "delete")
def page(self) -> None:
html.p(
_("Here you can add icons, for example to use them in bookmarks or "
"in custom actions of views. Allowed are single PNG image files "
"with a maximum size of 80x80 px. Custom actions have to be defined "
"in the global settings and can be used in the custom icons rules "
"of hosts and services."))
html.begin_form('upload_form', method='POST')
self._vs_upload().render_input('_upload_icon', None)
html.hidden_fields()
html.end_form()
icons = sorted(self._load_custom_icons().items())
with table_element("icons", _("Custom Icons")) as table:
for icon_name, category_name in icons:
table.row()
table.cell(_("Actions"), css="buttons")
delete_url = make_confirm_link(
url=make_action_link([("mode", "icons"),
("_delete", icon_name)]),
message=_(
"Do you really want to delete the icon <b>%s</b>?") %
icon_name,
)
html.icon_button(delete_url, _("Delete this Icon"), "delete")
table.cell(_("Icon"),
html.render_icon(icon_name),
css="buttons")
table.cell(_("Name"), icon_name)
table.cell(_("Category"),
IconSelector.category_alias(category_name))
def page(self):
with table_element("roles") as table:
users = userdb.load_users()
for rid, role in sorted(self._roles.items(),
key=lambda a: (a[1]["alias"], a[0])):
table.row()
# Actions
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link([("mode",
"edit_role"),
("edit", rid)])
clone_url = make_action_link([("mode", "roles"),
("_clone", rid)])
delete_url = make_confirm_link(
url=make_action_link([("mode", "roles"),
("_delete", rid)]),
message=_("Do you really want to delete the role %s?") %
rid,
)
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Clone"), "clone")
if not role.get("builtin"):
html.icon_button(delete_url, _("Delete this role"),
"delete")
# ID
table.cell(_("Name"), rid)
# Alias
table.cell(_("Alias"), role["alias"])
# Type
table.cell(
_("Type"),
_("builtin") if role.get("builtin") else _("custom"))
# Modifications
table.cell(
_("Modifications"),
html.render_span(
str(len(role["permissions"])),
title=
_("That many permissions do not use the factory defaults."
)))
# Users
table.cell(
_("Users"),
HTML(", ").join([
html.render_a(
user.get("alias", user_id),
watolib.folder_preserving_link([
("mode", "edit_user"), ("edit", user_id)
])) for (user_id, user) in users.items()
if rid in user["roles"]
]))
def page(self):
with table_element() as table:
for index, connection in enumerate(load_connection_config()):
table.row()
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link([
("mode", "edit_ldap_connection"), ("id", connection["id"])
])
delete_url = make_confirm_link(
url=make_action_link([("mode", "ldap_config"),
("_delete", index)]),
message=
_("Do you really want to delete the LDAP connection <b>%s</b>?"
) % connection["id"],
)
drag_url = make_action_link([("mode", "ldap_config"),
("_move", index)])
clone_url = watolib.folder_preserving_link([
("mode", "edit_ldap_connection"),
("clone", connection["id"])
])
html.icon_button(edit_url, _("Edit this LDAP connection"),
"edit")
html.icon_button(clone_url,
_("Create a copy of this LDAP connection"),
"clone")
html.element_dragger_url("tr", base_url=drag_url)
html.icon_button(delete_url, _("Delete this LDAP connection"),
"delete")
table.cell("", css="narrow")
if connection.get("disabled"):
html.icon(
"disabled",
_("This connection is currently not being used for synchronization."
),
)
else:
html.empty_icon_button()
table.cell(_("ID"), connection["id"])
if cmk_version.is_managed_edition():
table.cell(_("Customer"),
managed.get_customer_name(connection))
table.cell(_("Description"))
url = connection.get("docu_url")
if url:
html.icon_button(
url,
_("Context information about this connection"),
"url",
target="_blank")
html.write_text(" ")
html.write_text(connection["description"])
def _show_aux_tag_icons(self, aux_tag: cmk.utils.tags.AuxTag) -> None:
if aux_tag.id in self._builtin_config.aux_tag_list.get_tag_ids():
html.i("(%s)" % _("builtin"))
return
edit_url = watolib.folder_preserving_link([("mode", "edit_auxtag"), ("edit", aux_tag.id)])
delete_url = make_confirm_link(
url=make_action_link([("mode", "tags"), ("_del_aux", aux_tag.id)]),
message=_("Do you really want to delete the auxiliary tag '%s'?") % aux_tag.id)
html.icon_button(edit_url, _("Edit this auxiliary tag"), "edit")
html.icon_button(delete_url, _("Delete this auxiliary tag"), "delete")
def _show_row_cells(self, table, name, group):
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link([("mode", "edit_%s_group" % self.type_name),
("edit", name)])
delete_url = make_confirm_link(
url=html.makeactionuri([("_delete", name)]),
message=_('Do you really want to delete the %s group "%s"?') % (self.type_name, name))
clone_url = watolib.folder_preserving_link([("mode", "edit_%s_group" % self.type_name),
("clone", name)])
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy of this group"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
table.cell(_("Name"), escaping.escape_attribute(name))
table.cell(_("Alias"), escaping.escape_attribute(group['alias']))
def _show_row_cells(self, table: Table, name: GroupName, group: GroupSpec) -> None:
table.cell(_("Actions"), css="buttons")
edit_url = watolib.folder_preserving_link(
[("mode", "edit_%s_group" % self.type_name), ("edit", name)]
)
delete_url = make_confirm_link(
url=makeactionuri(request, transactions, [("_delete", name)]),
message=_('Do you really want to delete the %s group "%s"?') % (self.type_name, name),
)
clone_url = watolib.folder_preserving_link(
[("mode", "edit_%s_group" % self.type_name), ("clone", name)]
)
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy of this group"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
table.cell(_("Name"), name)
table.cell(_("Alias"), group["alias"])
def _action_buttons(self, name):
edit_url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"),
("edit", name),
])
clone_url = watolib.folder_preserving_link([
("mode", "edit_timeperiod"),
("clone", name),
])
delete_url = make_confirm_link(
url=make_action_link([
("mode", "timeperiods"),
("_delete", name),
]),
message=_("Do you really want to delete the time period '%s'?" % name))
html.icon_button(edit_url, _("Properties"), "edit")
html.icon_button(clone_url, _("Create a copy"), "clone")
html.icon_button(delete_url, _("Delete"), "delete")
def _page_menu_entries_actions(self) -> Iterator[PageMenuEntry]:
if not self._log_exists():
return
if not user.may("wato.auditlog"):
return
if not user.may("wato.edit"):
return
if user.may("wato.clear_auditlog"):
yield PageMenuEntry(
title=_("Clear log"),
icon_name="delete",
item=make_simple_link(
make_confirm_link(
url=makeactionuri(request, transactions, [("_action", "clear")]),
message=_("Do you really want to clear the audit log?"),
)),
)
def _show_user_list(self):
visible_custom_attrs = [
(name, attr) for name, attr in userdb.get_user_attributes() if attr.show_in_table()
]
users = userdb.load_users()
entries = list(users.items())
html.begin_form("bulk_delete_form", method="POST")
roles = userdb_utils.load_roles()
timeperiods = watolib.timeperiods.load_timeperiods()
contact_groups = load_contact_group_information()
with table_element("users", None, empty_text=_("No users are defined yet.")) as table:
online_threshold = time.time() - config.user_online_maxage
for uid, user in sorted(entries, key=lambda x: x[1].get("alias", x[0]).lower()):
table.row()
# Checkboxes
table.cell(html.render_input("_toggle_group",
type_="button",
class_="checkgroup",
onclick="cmk.selection.toggle_all_rows();",
value='X'),
sortable=False,
css="checkbox")
if uid != config.user.id:
html.checkbox("_c_user_%s" % ensure_str(base64.b64encode(uid.encode("utf-8"))))
user_connection_id = cleanup_connection_id(user.get('connector'))
connection = get_connection(user_connection_id)
# Buttons
table.cell(_("Actions"), css="buttons")
if connection: # only show edit buttons when the connector is available and enabled
edit_url = watolib.folder_preserving_link([("mode", "edit_user"),
("edit", uid)])
html.icon_button(edit_url, _("Properties"), "edit")
clone_url = watolib.folder_preserving_link([("mode", "edit_user"),
("clone", uid)])
html.icon_button(clone_url, _("Create a copy of this user"), "clone")
delete_url = make_confirm_link(
url=make_action_link([("mode", "users"), ("_delete", uid)]),
message=_("Do you really want to delete the user %s?") % uid,
)
html.icon_button(delete_url, _("Delete"), "delete")
notifications_url = watolib.folder_preserving_link([("mode", "user_notifications"),
("user", uid)])
if rulebased_notifications_enabled():
html.icon_button(notifications_url, _("Custom notification table of this user"),
"notifications")
# ID
table.cell(_("ID"), uid)
# Online/Offline
if config.user.may("wato.show_last_user_activity"):
last_seen = userdb.get_last_activity(uid, user)
user.get('last_seen', 0)
if last_seen >= online_threshold:
title = _('Online')
img_txt = 'online'
elif last_seen != 0:
title = _('Offline')
img_txt = 'offline'
elif last_seen == 0:
title = _('Never logged in')
img_txt = 'inactive'
title += ' (%s %s)' % (render.date(last_seen), render.time_of_day(last_seen))
table.cell(_("Act."))
html.icon(img_txt, title)
table.cell(_("Last seen"))
if last_seen != 0:
html.write_text("%s %s" %
(render.date(last_seen), render.time_of_day(last_seen)))
else:
html.write_text(_("Never logged in"))
if cmk_version.is_managed_edition():
table.cell(_("Customer"), managed.get_customer_name(user))
# Connection
if connection:
table.cell(_("Connection"),
'%s (%s)' % (connection.short_title(), user_connection_id))
locked_attributes = userdb.locked_attributes(user_connection_id)
else:
table.cell(_("Connection"),
"%s (%s) (%s)" % (_("UNKNOWN"), user_connection_id, _("disabled")),
css="error")
locked_attributes = []
# Authentication
if "automation_secret" in user:
auth_method = _("Automation")
elif user.get("password") or 'password' in locked_attributes:
auth_method = _("Password")
else:
auth_method = "<i>%s</i>" % _("none")
table.cell(_("Authentication"), auth_method)
table.cell(_("State"))
if user.get("locked", False):
html.icon('user_locked', _('The login is currently locked'))
if "disable_notifications" in user and isinstance(user["disable_notifications"],
bool):
disable_notifications_opts = {"disable": user["disable_notifications"]}
else:
disable_notifications_opts = user.get("disable_notifications", {})
if disable_notifications_opts.get("disable", False):
html.icon('notif_disabled', _('Notifications are disabled'))
# Full name / Alias
table.text_cell(_("Alias"), user.get("alias", ""))
# Email
table.text_cell(_("Email"), user.get("email", ""))
# Roles
table.cell(_("Roles"))
if user.get("roles", []):
role_links = [(watolib.folder_preserving_link([("mode", "edit_role"),
("edit", role)]),
roles[role].get("alias")) for role in user["roles"]]
html.write_html(
HTML(", ").join(
html.render_a(alias, href=link) for (link, alias) in role_links))
# contact groups
table.cell(_("Contact groups"))
cgs = user.get("contactgroups", [])
if cgs:
cg_aliases = [
contact_groups[c]['alias'] if c in contact_groups else c for c in cgs
]
cg_urls = [
watolib.folder_preserving_link([("mode", "edit_contact_group"),
("edit", c)]) for c in cgs
]
html.write_html(
HTML(", ").join(
html.render_a(content, href=url)
for (content, url) in zip(cg_aliases, cg_urls)))
else:
html.i(_("none"))
#table.cell(_("Sites"))
#html.write(vs_authorized_sites().value_to_text(user.get("authorized_sites",
# vs_authorized_sites().default_value())))
# notifications
if not rulebased_notifications_enabled():
table.cell(_("Notifications"))
if not cgs:
html.i(_("not a contact"))
elif not user.get("notifications_enabled", True):
html.write_text(_("disabled"))
elif user.get("host_notification_options", "") == "" and \
user.get("service_notification_options", "") == "":
html.write_text(_("all events disabled"))
else:
tp = user.get("notification_period", "24X7")
if tp not in timeperiods:
tp = tp + _(" (invalid)")
elif tp not in watolib.timeperiods.builtin_timeperiods():
url = watolib.folder_preserving_link([("mode", "edit_timeperiod"),
("edit", tp)])
tp = html.render_a(timeperiod_spec_alias(timeperiods[tp], tp), href=url)
else:
tp = timeperiod_spec_alias(timeperiods[tp], tp)
html.write(tp)
# the visible custom attributes
for name, attr in visible_custom_attrs:
vs = attr.valuespec()
table.cell(escaping.escape_attribute(_u(vs.title())))
html.write(vs.value_to_text(user.get(name, vs.default_value())))
html.hidden_fields()
html.end_form()
if not load_contact_group_information():
url = "wato.py?mode=contact_groups"
html.open_div(class_="info")
html.write(
_("Note: you haven't defined any contact groups yet. If you <a href='%s'>"
"create some contact groups</a> you can assign users to them und thus "
"make them monitoring contacts. Only monitoring contacts can receive "
"notifications.") % url)
html.write(" you can assign users to them und thus "
"make them monitoring contacts. Only monitoring contacts can receive "
"notifications.")
html.close_div()
