def render(self, what):
html.open_div(class_="group")
html.text_input("_ack_comment",
id_="ack_comment",
size=60,
submit="_acknowledge",
label=_("Comment"),
required=True)
html.close_div()
html.open_div(class_="group")
html.checkbox("_ack_sticky", config.view_action_defaults["ack_sticky"], label=_("sticky"))
html.checkbox("_ack_notify",
config.view_action_defaults["ack_notify"],
label=_("send notification"))
html.checkbox("_ack_persistent",
config.view_action_defaults["ack_persistent"],
label=_('persistent comment'))
html.close_div()
html.open_div(class_="group")
self._vs_expire().render_input("_ack_expire",
config.view_action_defaults.get("ack_expire", 0))
html.help(
_("Note: Expiration of acknowledgements only works when using the Checkmk Micro Core."))
html.close_div()
html.open_div(class_="group")
html.button("_acknowledge", _("Acknowledge"), cssclass="hot")
html.button("_remove_ack", _("Remove acknowledgement"), formnovalidate=True)
html.close_div()
def section(title: Union[None, HTML, str] = None,
checkbox: Union[None, HTML, str, Tuple[str, bool, str]] = None,
section_id: Optional[str] = None,
simple: bool = False,
hide: bool = False,
legend: bool = True,
css: Optional[str] = None,
is_show_more: bool = False) -> None:
global g_section_open
section_close()
html.open_tr(
id_=section_id,
class_=[css, "show_more_mode" if is_show_more else "basic"],
style="display:none;" if hide else None,
)
if legend:
html.open_td(class_=["legend", "simple" if simple else None])
if title:
html.open_div(
class_=["title", "withcheckbox" if checkbox else None],
title=escaping.strip_tags(title))
html.write(escaping.escape_text(title))
html.span('.' * 200, class_="dots")
html.close_div()
if checkbox:
html.open_div(class_="checkbox")
if isinstance(checkbox, (str, HTML)):
html.write(checkbox)
else:
name, active, attrname = checkbox
html.checkbox(
name,
active,
onclick='cmk.wato.toggle_attribute(this, \'%s\')' %
attrname)
html.close_div()
html.close_td()
html.open_td(class_=["content", "simple" if simple else None])
g_section_open = True
def _select_attributes_for_bulk_cleanup(self, hosts):
num_shown = 0
for attr in host_attribute_registry.get_sorted_host_attributes():
attrname = attr.name()
# only show attributes that at least on host have set
num_haveit = 0
for host in hosts:
if host.has_explicit_attribute(attrname):
num_haveit += 1
if num_haveit == 0:
continue
# If the attribute is mandatory and no value is inherited
# by file or folder, the attribute cannot be cleaned.
container = self._folder
is_inherited = False
while container:
if container.has_explicit_attribute(attrname):
is_inherited = True
break
container = container.parent()
num_shown += 1
# Legend and Help
forms.section(attr.title())
if attr.is_mandatory() and not is_inherited:
html.write_text(
_("This attribute is mandatory and there is no value "
"defined in the host list or any parent folder."))
else:
label = "clean this attribute on <b>%s</b> hosts" % \
(num_haveit == len(hosts) and "all selected" or str(num_haveit))
html.checkbox("_clean_%s" % attrname, False, label=label)
html.help(attr.help())
return num_shown > 0
def section(title=None,
checkbox=None,
section_id=None,
simple=False,
hide=False,
legend=True,
css=None):
# type: (Union[None, HTML, Text], Union[None, HTML, str, Text, Tuple[str, bool, str]], Optional[str], bool, bool, bool, Optional[str]) -> None
global g_section_open
if g_section_open:
html.close_td()
html.close_tr()
html.open_tr(id_=section_id,
class_=[css],
style="display:none;" if hide else None)
if legend:
html.open_td(class_=["legend", "simple" if simple else None])
if title:
html.open_div(
class_=["title", "withcheckbox" if checkbox else None],
title=escaping.strip_tags(title))
html.write(escaping.escape_text(title))
html.span('.' * 200, class_="dots")
html.close_div()
if checkbox:
html.open_div(class_="checkbox")
if isinstance(checkbox, six.string_types + (HTML, )):
html.write(checkbox)
else:
name, active, attrname = checkbox
html.checkbox(
name,
active,
onclick='cmk.wato.toggle_attribute(this, \'%s\')' %
attrname)
html.close_div()
html.close_td()
html.open_td(class_=["content", "simple" if simple else None])
g_section_open = True
def _select_attributes_for_bulk_cleanup(self, hosts):
attributes = self._get_attributes_for_bulk_cleanup(hosts)
for attr, is_inherited, num_haveit in attributes:
# Legend and Help
forms.section(attr.title())
if attr.is_mandatory() and not is_inherited:
html.write_text(
_("This attribute is mandatory and there is no value "
"defined in the host list or any parent folder."))
else:
label = "clean this attribute on <b>%s</b> hosts" % \
(num_haveit == len(hosts) and "all selected" or str(num_haveit))
html.checkbox("_clean_%s" % attr.name(), False, label=label)
html.help(attr.help())
forms.end()
if not attributes:
html.write_text(
_("The selected hosts have no explicit attributes"))
def display(self) -> None:
html.text_input(self._varprefix + "name")
html.br()
html.begin_radio_group(horizontal=True)
html.radiobutton(self._varprefix + "match", "exact", True, label=_("exact match"))
html.radiobutton(self._varprefix + "match",
"regex",
False,
label=_("regular expression, substring match"))
html.end_radio_group()
html.br()
html.open_span(class_="min_max_row")
html.write_text(_("Min. Version: "))
html.text_input(self._varprefix + "version_from", size=9)
html.write_text(" ")
html.write_text(_("Max. Vers.: "))
html.text_input(self._varprefix + "version_to", size=9)
html.close_span()
html.br()
html.checkbox(self._varprefix + "negate",
False,
label=_("Negate: find hosts <b>not</b> having this package"))
def section(title=None,
checkbox=None,
section_id=None,
simple=False,
hide=False,
legend=True,
css=None):
global g_section_open
if g_section_open:
html.close_td()
html.close_tr()
html.open_tr(id_=section_id,
class_=[css],
style="display:none;" if hide else None)
if legend:
html.open_td(class_=["legend", "simple" if simple else None])
if title:
html.open_div(
class_=["title", "withcheckbox" if checkbox else None],
title=html.strip_tags(title))
html.write(html.permissive_attrencode(title))
html.span('.' * 100, class_="dots")
html.close_div()
if checkbox:
html.open_div(class_="checkbox")
if isinstance(checkbox, six.string_types + (HTML, )):
html.write(checkbox)
else:
name, active, attrname = checkbox
html.checkbox(
name,
active,
onclick='cmk.wato.toggle_attribute(this, \'%s\')' %
attrname)
html.close_div()
html.close_td()
html.open_td(class_=["content", "simple" if simple else None])
g_section_open = True
def display(self, value: FilterHTTPVariables) -> None:
html.text_input(self._varprefix + "name")
html.br()
display_filter_radiobuttons(varname=self._varprefix + "match",
options=[("exact", _("exact match")),
("regex", _("regular expression, substring match"))],
default="exact",
value=value)
html.br()
html.open_span(class_="min_max_row")
html.write_text(_("Min. Version: "))
html.text_input(self._varprefix + "version_from",
default_value=value.get(self._varprefix + "version_from", ""),
size=9)
html.write_text(" ")
html.write_text(_("Max. Vers.: "))
html.text_input(self._varprefix + "version_to",
default_value=value.get(self._varprefix + "version_from", ""),
size=9)
html.close_span()
html.br()
html.checkbox(self._varprefix + "negate",
False,
label=_("Negate: find hosts <b>not</b> having this package"))
def render(self, what):
html.button("_acknowledge", _("Acknowledge"))
html.button("_remove_ack", _("Remove Acknowledgement"))
html.hr()
html.checkbox("_ack_sticky", config.view_action_defaults["ack_sticky"], label=_("sticky"))
html.checkbox("_ack_notify",
config.view_action_defaults["ack_notify"],
label=_("send notification"))
html.checkbox("_ack_persistent",
config.view_action_defaults["ack_persistent"],
label=_('persistent comment'))
html.hr()
self._vs_expire().render_input("_ack_expire",
config.view_action_defaults.get("ack_expire", 0))
html.help(
_("Note: Expiration of acknowledgements only works when using the Checkmk Micro Core."))
html.hr()
html.write_text(_("Comment") + ": ")
html.text_input("_ack_comment", size=48, submit="_acknowledge")
def _activation_status(self):
with table_element("site-status",
searchable=False,
sortable=False,
css="activation") as table:
for site_id, site in sort_sites(
cmk.gui.watolib.changes.activation_sites()):
table.row()
site_status, status = self._get_site_status(site_id, site)
is_online = self._site_is_online(status)
is_logged_in = self._site_is_logged_in(site_id, site)
has_foreign = self._site_has_foreign_changes(site_id)
can_activate_all = not has_foreign or config.user.may(
"wato.activateforeign")
# Disable actions for offline sites and not logged in sites
if not is_online or not is_logged_in:
can_activate_all = False
need_restart = self._is_activate_needed(site_id)
need_sync = self.is_sync_needed(site_id)
need_action = need_restart or need_sync
# Activation checkbox
table.cell("", css="buttons")
if can_activate_all and need_action:
html.checkbox("site_%s" % site_id,
cssclass="site_checkbox")
# Iconbuttons
table.cell(_("Actions"), css="buttons")
if config.user.may("wato.sites"):
edit_url = watolib.folder_preserving_link([
("mode", "edit_site"), ("edit", site_id)
])
html.icon_button(edit_url,
_("Edit the properties of this site"),
"edit")
# State
if can_activate_all and need_sync:
html.icon_button(
url="javascript:void(0)",
id_="activate_%s" % site_id,
cssclass="activate_site",
title=
_("This site is not update and needs a replication. Start it now."
),
icon="need_replicate",
onclick=
"cmk.activation.activate_changes(\"site\", \"%s\")" %
site_id)
if can_activate_all and need_restart:
html.icon_button(
url="javascript:void(0)",
id_="activate_%s" % site_id,
cssclass="activate_site",
title=
_("This site needs a restart for activating the changes. Start it now."
),
icon="need_restart",
onclick=
"cmk.activation.activate_changes(\"site\", \"%s\")" %
site_id)
if can_activate_all and not need_action:
html.icon(_("This site is up-to-date."), "siteuptodate")
site_url = site.get("multisiteurl")
if site_url:
html.icon_button(
site_url,
_("Open this site's local web user interface"),
"url",
target="_blank")
table.text_cell(_("Site"), site.get("alias", site_id))
# Livestatus
table.cell(_("Status"), css="narrow nobr")
html.status_label(content=status,
status=status,
title=_("This site is %s") % status)
# Livestatus-/Check_MK-Version
table.cell(_("Version"),
site_status.get("livestatus_version", ""),
css="narrow nobr")
table.cell(_("Changes"),
"%d" % len(self._changes_of_site(site_id)),
css="number narrow nobr")
table.cell(_("Progress"), css="repprogress")
html.open_div(id_="site_%s_status" % site_id, class_=["msg"])
html.close_div()
html.open_div(id_="site_%s_progress" % site_id,
class_=["progress"])
html.close_div()
# Hidden on initial rendering and shown on activation start
table.cell(_("Details"), css="details")
html.open_div(id_="site_%s_details" % site_id)
# Shown on initial rendering and hidden on activation start
table.cell(_("Last result"), css="last_result")
last_state = self._last_activation_state(site_id)
if not is_logged_in:
html.write_text(_("Is not logged in.") + " ")
if not last_state:
html.write_text(_("Has never been activated"))
else:
html.write_text("%s: %s. " %
(_("State"), last_state["_status_text"]))
if last_state["_status_details"]:
html.write(last_state["_status_details"])
def _render_table_option(self, section_title, label, help_text):
"""Helper method to implement _show_in_table_option."""
forms.section(section_title)
html.help(help_text)
html.checkbox('show_in_table', self._attr.get('show_in_table', False), label=label)
def page(self):
# TODO: remove subclass specific things specifict things (everything with _type == 'user')
html.begin_form("attr")
forms.header(_("Properties"))
forms.section(_("Name"), simple=not self._new)
html.help(
_("The name of the attribute is used as an internal key. It cannot be "
"changed later."))
if self._new:
html.text_input("name", self._attr.get('name'))
html.set_focus("name")
else:
html.write_text(self._name)
html.set_focus("title")
forms.section(_("Title") + "<sup>*</sup>")
html.help(_("The title is used to label this attribute."))
html.text_input("title", self._attr.get('title'))
forms.section(_('Topic'))
html.help(
_('The attribute is added to this section in the edit dialog.'))
html.dropdown('topic',
self._topics,
deflt=self._attr.get('topic', self._default_topic))
forms.section(_('Help Text') + "<sup>*</sup>")
html.help(
_('You might want to add some helpful description for the attribute.'
))
html.text_area('help', self._attr.get('help', ''))
forms.section(_('Data type'))
html.help(_('The type of information to be stored in this attribute.'))
if self._new:
html.dropdown('type',
custom_attr_types(),
deflt=self._attr.get('type'))
else:
html.write(dict(custom_attr_types())[self._attr.get('type')])
self._add_extra_form_sections()
forms.section(_('Show in WATO host table'))
html.help(
_('This attribute is only visibile on the edit host and folder pages by default, but '
'you can also make it visible in the host overview tables of WATO.'
))
html.checkbox(
'show_in_table',
self._attr.get('show_in_table', False),
label=_(
"Show the setting of the attribute in the WATO host list table"
))
forms.section(_('Add to monitoring configuration'))
html.help(self._macro_help)
html.checkbox('add_custom_macro',
self._attr.get('add_custom_macro', False),
label=self._macro_label)
forms.end()
html.show_localization_hint()
html.button("save", _("Save"))
html.hidden_fields()
html.end_form()
def render(self, what):
html.write_text(_('Downtime Comment') + ": ")
html.text_input("_down_comment", "", size=60, submit="")
html.hr()
html.button("_down_from_now", _("From now for"))
html.nbsp()
html.number_input("_down_minutes", 60, size=4, submit="_down_from_now")
html.write_text(" " + _("minutes"))
html.hr()
for time_range in config.user_downtime_timeranges:
html.button("_downrange__%s" % time_range['end'],
_u(time_range['title']))
if what != "aggr" and config.user.may("action.remove_all_downtimes"):
html.write_text(" - ")
html.button("_down_remove", _("Remove all"))
html.hr()
if config.adhoc_downtime and config.adhoc_downtime.get("duration"):
adhoc_duration = config.adhoc_downtime.get("duration")
adhoc_comment = config.adhoc_downtime.get("comment", "")
html.button("_down_adhoc",
_("Adhoc for %d minutes") % adhoc_duration)
html.nbsp()
html.write_text(_('with comment') + ": ")
html.write(adhoc_comment)
html.hr()
html.button("_down_custom", _("Custom time range"))
html.datetime_input("_down_from", time.time(), submit="_down_custom")
html.write_text(" " + _('to') + " ")
html.datetime_input("_down_to",
time.time() + 7200,
submit="_down_custom")
html.hr()
html.checkbox("_down_flexible",
False,
label="%s " % _('flexible with max. duration'))
html.time_input("_down_duration", 2, 0)
html.write_text(" " + _('(HH:MM)'))
if what == "host":
html.hr()
html.checkbox("_include_childs",
False,
label=_('Also set downtime on child hosts'))
html.write_text(" ")
html.checkbox("_include_childs_recurse",
False,
label=_('Do this recursively'))
elif what == "service":
html.hr()
html.checkbox("_on_hosts",
False,
label=_('Schedule downtimes on the affected '
'<b>hosts</b> instead of on the individual '
'services'))
if self._has_recurring_downtimes():
html.hr()
html.checkbox(
"_down_do_recur",
False,
label=_("Repeat this downtime on a regular basis every"))
html.write_text(" ")
from cmk.gui.cee.plugins.wato.cmc import recurring_downtimes_types
recurring_selections = [
(str(k), v)
for (k, v) in sorted(recurring_downtimes_types().items())
]
html.dropdown("_down_recurring", recurring_selections, deflt="3")
html.write_text(_("(This only works when using CMC)"))
def render_input(self, varprefix: str, value: Any) -> None:
value = convert_cgroups_from_tuple(value)
# If we're just editing a host, then some of the checkboxes will be missing.
# This condition is not very clean, but there is no other way to savely determine
# the context.
is_host = bool(request.var("host")) or request.var("mode") == "newhost"
is_search = varprefix == "host_search"
# Only show contact groups I'm currently in and contact
# groups already listed here.
self.load_data()
self._vs_contactgroups().render_input(varprefix + self.name(),
value["groups"])
html.hr()
if is_host:
html.checkbox(
varprefix + self.name() + "_use",
value["use"],
label=_("Add these contact groups to the host"),
)
elif not is_search:
html.checkbox(
varprefix + self.name() + "_recurse_perms",
value["recurse_perms"],
label=_(
"Give these groups also <b>permission on all subfolders</b>"
),
)
html.hr()
html.checkbox(
varprefix + self.name() + "_use",
value["use"],
label=
_("Add these groups as <b>contacts</b> to all hosts <b>in this folder</b>"
),
)
html.br()
html.checkbox(
varprefix + self.name() + "_recurse_use",
value["recurse_use"],
label=
_("Add these groups as <b>contacts</b> to all hosts <b>in all subfolders of this folder</b>"
),
)
html.hr()
html.help(
_("With this option contact groups that are added to hosts are always "
"being added to services, as well. This only makes a difference if you have "
"assigned other contact groups to services via rules in <i>Host & Service Parameters</i>. "
"As long as you do not have any such rule a service always inherits all contact groups "
"from its host."))
html.checkbox(
varprefix + self.name() + "_use_for_services",
value.get("use_for_services", False),
label=_("Always add host contact groups also to its services")
if is_host else
_("Always add these groups as <b>contacts</b> to all services <b>in all subfolders of this folder</b>"
),
)
def _show_start_form(self):
html.begin_form("parentscan", method="POST")
html.hidden_fields()
# Mode of action
html.open_p()
if not self._complete_folder:
num_selected = len(get_hosts_from_checkboxes())
html.write_text(
_("You have selected <b>%d</b> hosts for parent scan. ") %
num_selected)
html.p(
_("The parent scan will try to detect the last gateway "
"on layer 3 (IP) before a host. This will be done by "
"calling <tt>traceroute</tt>. If a gateway is found by "
"that way and its IP address belongs to one of your "
"monitored hosts, that host will be used as the hosts "
"parent. If no such host exists, an artifical ping-only "
"gateway host will be created if you have not disabled "
"this feature."))
forms.header(_("Settings for Parent Scan"))
self._settings = config.user.load_file(
"parentscan", {
"where": "subfolder",
"alias": _("Created by parent scan"),
"recurse": True,
"select": "noexplicit",
"timeout": 8,
"probes": 2,
"ping_probes": 5,
"max_ttl": 10,
"force_explicit": False,
})
# Selection
forms.section(_("Selection"))
if self._complete_folder:
html.checkbox("recurse",
self._settings["recurse"],
label=_("Include all subfolders"))
html.br()
html.radiobutton(
"select", "noexplicit", self._settings["select"] == "noexplicit",
_("Skip hosts with explicit parent definitions (even if empty)") +
"<br>")
html.radiobutton(
"select", "no", self._settings["select"] == "no",
_("Skip hosts hosts with non-empty parents (also if inherited)") +
"<br>")
html.radiobutton("select", "ignore",
self._settings["select"] == "ignore",
_("Scan all hosts") + "<br>")
# Performance
forms.section(_("Performance"))
html.open_table()
html.open_tr()
html.open_td()
html.write_text(_("Timeout for responses") + ":")
html.close_td()
html.open_td()
html.number_input("timeout", self._settings["timeout"], size=2)
html.write_text(_("sec"))
html.close_td()
html.close_tr()
html.open_tr()
html.open_td()
html.write_text(_("Number of probes per hop") + ":")
html.close_td()
html.open_td()
html.number_input("probes", self._settings["probes"], size=2)
html.close_td()
html.close_tr()
html.open_tr()
html.open_td()
html.write_text(_("Maximum distance (TTL) to gateway") + ":")
html.close_td()
html.open_td()
html.number_input("max_ttl", self._settings["max_ttl"], size=2)
html.close_td()
html.close_tr()
html.open_tr()
html.open_td()
html.write_text(_("Number of PING probes") + ":")
html.help(
_("After a gateway has been found, Check_MK checks if it is reachable "
"via PING. If not, it is skipped and the next gateway nearer to the "
"monitoring core is being tried. You can disable this check by setting "
"the number of PING probes to 0."))
html.close_td()
html.open_td()
html.number_input("ping_probes",
self._settings.get("ping_probes", 5),
size=2)
html.close_td()
html.close_tr()
html.close_table()
# Configuring parent
forms.section(_("Configuration"))
html.checkbox(
"force_explicit",
self._settings["force_explicit"],
label=
_("Force explicit setting for parents even if setting matches that of the folder"
))
# Gateway creation
forms.section(_("Creation of gateway hosts"))
html.write_text(_("Create gateway hosts in"))
html.open_ul()
html.radiobutton(
"where", "subfolder", self._settings["where"] == "subfolder",
_("in the subfolder <b>%s/Parents</b>") %
watolib.Folder.current_disk_folder().title())
html.br()
html.radiobutton(
"where", "here", self._settings["where"] == "here",
_("directly in the folder <b>%s</b>") %
watolib.Folder.current_disk_folder().title())
html.br()
html.radiobutton("where", "there", self._settings["where"] == "there",
_("in the same folder as the host"))
html.br()
html.radiobutton("where", "nowhere",
self._settings["where"] == "nowhere",
_("do not create gateway hosts"))
html.close_ul()
html.write_text(_("Alias for created gateway hosts") + ": ")
html.text_input("alias", self._settings["alias"])
forms.end()
# Start button
html.button("_start", _("Start"))
html.hidden_fields()
html.end_form()
def page(self):
# Let exceptions from loading notification scripts happen now
watolib.load_notification_scripts()
html.begin_form("user", method="POST")
html.prevent_password_auto_completion()
forms.header(_("Identity"))
# ID
forms.section(_("Username"), simple=not self._is_new_user)
if self._is_new_user:
vs_user_id = UserID(allow_empty=False)
else:
vs_user_id = FixedValue(self._user_id)
vs_user_id.render_input("user_id", self._user_id)
def lockable_input(name, dflt):
if not self._is_locked(name):
html.text_input(name, self._user.get(name, dflt), size=50)
else:
html.write_text(self._user.get(name, dflt))
html.hidden_field(name, self._user.get(name, dflt))
# Full name
forms.section(_("Full name"))
lockable_input('alias', self._user_id)
html.help(_("Full name or alias of the user"))
# Email address
forms.section(_("Email address"))
email = self._user.get("email", "")
if not self._is_locked("email"):
EmailAddressUnicode().render_input("email", email)
else:
html.write_text(email)
html.hidden_field("email", email)
html.help(
_("The email address is optional and is needed "
"if the user is a monitoring contact and receives notifications "
"via Email."))
forms.section(_("Pager address"))
lockable_input('pager', '')
html.help(_("The pager address is optional "))
if cmk.is_managed_edition():
forms.section(self._vs_customer.title())
self._vs_customer.render_input("customer", managed.get_customer_id(self._user))
html.help(self._vs_customer.help())
vs_sites = self._vs_sites()
forms.section(vs_sites.title())
authorized_sites = self._user.get("authorized_sites", vs_sites.default_value())
if not self._is_locked("authorized_sites"):
vs_sites.render_input("authorized_sites", authorized_sites)
else:
html.write_html(vs_sites.value_to_text(authorized_sites))
html.help(vs_sites.help())
self._show_custom_user_attributes('ident')
forms.header(_("Security"))
forms.section(_("Authentication"))
is_automation = self._user.get("automation_secret", None) is not None
html.radiobutton("authmethod", "password", not is_automation,
_("Normal user login with password"))
html.open_ul()
html.open_table()
html.open_tr()
html.td(_("password:"******"_password_" + self._pw_suffix(), autocomplete="new-password")
html.close_td()
html.close_tr()
html.open_tr()
html.td(_("repeat:"))
html.open_td()
html.password_input("_password2_" + self._pw_suffix(), autocomplete="new-password")
html.write_text(" (%s)" % _("optional"))
html.close_td()
html.close_tr()
html.open_tr()
html.td("%s:" % _("Enforce change"))
html.open_td()
# Only make password enforcement selection possible when user is allowed to change the PW
if self._is_new_user or config.user_may(self._user_id,
'general.edit_profile') and config.user_may(
self._user_id, 'general.change_password'):
html.checkbox("enforce_pw_change",
self._user.get("enforce_pw_change", False),
label=_("Change password at next login or access"))
else:
html.write_text(
_("Not permitted to change the password. Change can not be enforced."))
else:
html.i(_('The password can not be changed (It is locked by the user connector).'))
html.hidden_field('_password', '')
html.hidden_field('_password2', '')
html.close_td()
html.close_tr()
html.close_table()
html.close_ul()
html.radiobutton("authmethod", "secret", is_automation,
_("Automation secret for machine accounts"))
html.open_ul()
html.text_input("_auth_secret",
self._user.get("automation_secret", ""),
size=30,
id_="automation_secret")
html.write_text(" ")
html.open_b(style=["position: relative", "top: 4px;"])
html.write(" ")
html.icon_button("javascript:cmk.wato.randomize_secret('automation_secret', 20);",
_("Create random secret"), "random")
html.close_b()
html.close_ul()
html.help(
_("If you want the user to be able to login "
"then specify a password here. Users without a login make sense "
"if they are monitoring contacts that are just used for "
"notifications. The repetition of the password is optional. "
"<br>For accounts used by automation processes (such as fetching "
"data from views for further procession), set the method to "
"<u>secret</u>. The secret will be stored in a local file. Processes "
"with read access to that file will be able to use Multisite as "
"a webservice without any further configuration."))
# Locking
forms.section(_("Disable password"), simple=True)
if not self._is_locked('locked'):
html.checkbox("locked",
self._user.get("locked", False),
label=_("disable the login to this account"))
else:
html.write_text(
_('Login disabled') if self._user.get("locked", False) else _('Login possible'))
html.hidden_field('locked', '1' if self._user.get("locked", False) else '')
html.help(
_("Disabling the password will prevent a user from logging in while "
"retaining the original password. Notifications are not affected "
"by this setting."))
forms.section(_("Idle timeout"))
idle_timeout = self._user.get("idle_timeout")
if not self._is_locked("idle_timeout"):
watolib.get_vs_user_idle_timeout().render_input("idle_timeout", idle_timeout)
else:
html.write_text(idle_timeout)
html.hidden_field("idle_timeout", idle_timeout)
# Roles
forms.section(_("Roles"))
entries = self._roles.items()
entries.sort(key=lambda x: (x[1]["alias"], x[0]))
is_member_of_at_least_one = False
for role_id, role in entries:
if not self._is_locked("roles"):
html.checkbox("role_" + role_id, role_id in self._user.get("roles", []))
url = watolib.folder_preserving_link([("mode", "edit_role"), ("edit", role_id)])
html.a(role["alias"], href=url)
html.br()
else:
is_member = role_id in self._user.get("roles", [])
if is_member:
is_member_of_at_least_one = True
url = watolib.folder_preserving_link([("mode", "edit_role"), ("edit", role_id)])
html.a(role["alias"], href=url)
html.br()
html.hidden_field("role_" + role_id, '1' if is_member else '')
if self._is_locked('roles') and not is_member_of_at_least_one:
html.i(_('No roles assigned.'))
self._show_custom_user_attributes('security')
# Contact groups
forms.header(_("Contact Groups"), isopen=False)
forms.section()
groups_page_url = watolib.folder_preserving_link([("mode", "contact_groups")])
group_assign_url = watolib.folder_preserving_link([("mode", "rulesets"),
("group", "grouping")])
if not self._contact_groups:
html.write(
_("Please first create some <a href='%s'>contact groups</a>") % groups_page_url)
else:
entries = sorted([(group['alias'] or c, c) for c, group in self._contact_groups.items()
])
is_member_of_at_least_one = False
for alias, gid in entries:
is_member = gid in self._user.get("contactgroups", [])
if not self._is_locked('contactgroups'):
html.checkbox("cg_" + gid, gid in self._user.get("contactgroups", []))
else:
if is_member:
is_member_of_at_least_one = True
html.hidden_field("cg_" + gid, '1' if is_member else '')
if not self._is_locked('contactgroups') or is_member:
url = watolib.folder_preserving_link([("mode", "edit_contact_group"),
("edit", gid)])
html.a(alias, href=url)
html.br()
if self._is_locked('contactgroups') and not is_member_of_at_least_one:
html.i(_('No contact groups assigned.'))
html.help(
_("Contact groups are used to assign monitoring "
"objects to users. If you haven't defined any contact groups yet, "
"then first <a href='%s'>do so</a>. Hosts and services can be "
"assigned to contact groups using <a href='%s'>rules</a>.<br><br>"
"If you do not put the user into any contact group "
"then no monitoring contact will be created for the user.") %
(groups_page_url, group_assign_url))
forms.header(_("Notifications"), isopen=False)
if not self._rbn_enabled():
forms.section(_("Enabling"), simple=True)
html.checkbox("notifications_enabled",
self._user.get("notifications_enabled", False),
label=_("enable notifications"))
html.help(
_("Notifications are sent out "
"when the status of a host or service changes."))
# Notification period
forms.section(_("Notification time period"))
choices = [(id_, "%s" % (tp["alias"])) for (id_, tp) in self._timeperiods.items()]
html.dropdown("notification_period",
choices,
deflt=self._user.get("notification_period"),
ordered=True)
html.help(
_("Only during this time period the "
"user will get notifications about host or service alerts."))
# Notification options
notification_option_names = { # defined here: _() must be executed always!
"host": {
"d": _("Host goes down"),
"u": _("Host gets unreachble"),
"r": _("Host goes up again"),
},
"service": {
"w": _("Service goes into warning state"),
"u": _("Service goes into unknown state"),
"c": _("Service goes into critical state"),
"r": _("Service recovers to OK"),
},
"both": {
"f": _("Start or end of flapping state"),
"s": _("Start or end of a scheduled downtime"),
}
}
forms.section(_("Notification Options"))
for title, what, opts in [(_("Host events"), "host", "durfs"),
(_("Service events"), "service", "wucrfs")]:
html.write_text("%s:" % title)
html.open_ul()
user_opts = self._user.get(what + "_notification_options", opts)
for opt in opts:
opt_name = notification_option_names[what].get(
opt, notification_option_names["both"].get(opt))
html.checkbox(what + "_" + opt, opt in user_opts, label=opt_name)
html.br()
html.close_ul()
html.help(
_("Here you specify which types of alerts "
"will be notified to this contact. Note: these settings will only be saved "
"and used if the user is member of a contact group."))
forms.section(_("Notification Method"))
watolib.get_vs_flexible_notifications().render_input(
"notification_method", self._user.get("notification_method"))
else:
forms.section(_("Fallback notifications"), simple=True)
html.checkbox("fallback_contact",
self._user.get("fallback_contact", False),
label=_("Receive fallback notifications"))
html.help(
_("In case none of your notification rules handles a certain event a notification "
"will be sent to this contact. This makes sure that in that case at least <i>someone</i> "
"gets notified. Furthermore this contact will be used for notifications to any host or service "
"that is not known to the monitoring. This can happen when you forward notifications "
"from the Event Console.<br><br>Notification fallback can also configured in the global "
"setting <a href=\"wato.py?mode=edit_configvar&varname=notification_fallback_email\">"
"Fallback email address for notifications</a>."))
self._show_custom_user_attributes('notify')
forms.header(_("Personal Settings"), isopen=False)
select_language(self._user)
self._show_custom_user_attributes('personal')
# Later we could add custom macros here, which then could be used
# for notifications. On the other hand, if we implement some check_mk
# --notify, we could directly access the data in the account with the need
# to store values in the monitoring core. We'll see what future brings.
forms.end()
html.button("save", _("Save"))
if self._is_new_user:
html.set_focus("user_id")
else:
html.set_focus("alias")
html.hidden_fields()
html.end_form()
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 = users.items()
html.begin_form("bulk_delete_form", method="POST")
roles = userdb.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" % base64.b64encode(uid.encode("utf-8")))
user_connection_id = userdb.cleanup_connection_id(user.get('connector'))
connection = userdb.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_action_link([("mode", "users"), ("_delete", uid)])
html.icon_button(delete_url, _("Delete"), "delete")
notifications_url = watolib.folder_preserving_link([("mode", "user_notifications"),
("user", uid)])
if watolib.load_configuration_settings().get("enable_rulebased_notifications"):
html.icon_button(notifications_url, _("Custom notification table of this user"),
"notifications")
# ID
table.cell(_("ID"), uid)
# Online/Offline
if config.save_user_access_times:
last_seen = 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(title, img_txt)
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.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(_('The login is currently locked'), 'user_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(_('Notifications are disabled'), 'notif_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 watolib.load_configuration_settings().get("enable_rulebased_notifications"):
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(timeperiods[tp].get("alias", tp), href=url)
else:
tp = timeperiods[tp].get("alias", tp)
html.write(tp)
# the visible custom attributes
for name, attr in visible_custom_attrs:
vs = attr.valuespec()
table.cell(html.attrencode(_u(vs.title())))
html.write(vs.value_to_text(user.get(name, vs.default_value())))
html.button("_bulk_delete_users", _("Bulk Delete"), "submit", style="margin-top:10px")
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()
def render(self, what):
html.open_div(class_="group")
html.text_input("_down_comment",
id_="down_comment",
size=60,
label=_("Comment"),
required=True)
html.close_div()
html.open_div(class_="group")
html.button("_down_from_now", _("From now for"), cssclass="hot")
html.nbsp()
html.text_input("_down_minutes",
default_value="60",
size=4,
submit="_down_from_now",
cssclass="number")
html.write_text(" " + _("minutes"))
html.close_div()
html.open_div(class_="group")
for time_range in config.user_downtime_timeranges:
html.button("_downrange__%s" % time_range['end'], _u(time_range['title']))
if what != "aggr" and config.user.may("action.remove_all_downtimes"):
html.write_text(" - ")
html.button("_down_remove", _("Remove all"))
html.close_div()
if config.adhoc_downtime and config.adhoc_downtime.get("duration"):
adhoc_duration = config.adhoc_downtime.get("duration")
adhoc_comment = config.adhoc_downtime.get("comment", "")
html.open_div(class_="group")
html.button("_down_adhoc", _("Adhoc for %d minutes") % adhoc_duration)
html.nbsp()
html.write_text(_('with comment') + ": ")
html.write(adhoc_comment)
html.close_div()
html.open_div(class_="group")
html.button("_down_custom", _("Custom time range"))
self._vs_down_from().render_input("_down_from", time.time())
html.write_text(" " + _('to') + " ")
self._vs_down_to().render_input("_down_to", time.time() + 7200)
html.close_div()
html.open_div(class_="group")
html.checkbox("_down_flexible", False, label="%s " % _('flexible with max. duration'))
self._vs_duration().render_input("_down_duration", 7200)
html.close_div()
if what == "host":
html.open_div(class_="group")
html.checkbox("_include_childs", False, label=_('Also set downtime on child hosts'))
html.write_text(" ")
html.checkbox("_include_childs_recurse", False, label=_('Do this recursively'))
html.close_div()
elif what == "service":
html.open_div(class_="group")
html.checkbox("_on_hosts",
False,
label=_('Schedule downtimes on the affected '
'<b>hosts</b> instead of on the individual '
'services'))
html.close_div()
if self._has_recurring_downtimes():
html.open_div(class_="group")
html.checkbox("_down_do_recur",
False,
label=_("Repeat this downtime on a regular basis every"))
from cmk.gui.cee.plugins.wato.cmc import recurring_downtimes_types # pylint: disable=no-name-in-module,import-outside-toplevel
recurring_selections: Choices = [
(str(k), v) for (k, v) in sorted(recurring_downtimes_types().items())
]
html.dropdown("_down_recurring", recurring_selections, deflt="3")
html.write_text(" " + _("(only works with the microcore)"))
html.close_div()
def page_list(cls):
cls.load()
# custom_columns = []
# render_custom_buttons = None
# render_custom_columns = None
# render_custom_context_buttons = None
# check_deletable_handler = None
cls.need_overriding_permission("edit")
html.header(cls.phrase("title_plural"))
html.begin_context_buttons()
html.context_button(cls.phrase("new"), cls.create_url(), "new_" + cls.type_name())
# TODO: Remove this legacy code as soon as views, dashboards and reports have been
# moved to pagetypes.py
html.context_button(_("Views"), "edit_views.py", "view")
html.context_button(_("Dashboards"), "edit_dashboards.py", "dashboard")
def has_reporting():
try:
# The suppression below is OK, we just want to check if the module is there.
import cmk.gui.cee.reporting # noqa: F401 # pylint: disable=unused-variable,redefined-outer-name
return True
except ImportError:
return False
if has_reporting():
html.context_button(_("Reports"), "edit_reports.py", "report")
# ## if render_custom_context_buttons:
# ## render_custom_context_buttons()
for other_type_name, other_pagetype in page_types.items():
if cls.type_name() != other_type_name:
html.context_button(
other_pagetype.phrase("title_plural").title(), '%ss.py' % other_type_name,
other_type_name)
html.end_context_buttons()
# Deletion
delname = html.request.var("_delete")
if delname and html.transaction_valid():
owner = UserId(html.request.get_unicode_input_mandatory('_owner', config.user.id))
try:
instance = cls.instance((owner, delname))
except KeyError:
raise MKUserError(
"_delete",
_("The %s you are trying to delete "
"does not exist.") % cls.phrase("title"))
if not instance.may_delete():
raise MKUserError("_delete", _("You are not permitted to perform this action."))
try:
if owner != config.user.id:
owned_by = _(" (owned by %s)") % owner
else:
owned_by = ""
c = html.confirm(
_("Please confirm the deletion of \"%s\"%s.") % (instance.title(), owned_by))
if c:
cls.remove_instance((owner, delname))
cls.save_user_instances(owner)
html.reload_sidebar()
elif c is False:
html.footer()
return
except MKUserError as e:
html.user_error(e)
# Bulk delete
if html.request.var("_bulk_delete_my") and html.transaction_valid():
if cls._bulk_delete_after_confirm("my") is False:
html.footer()
return
elif html.request.var("_bulk_delete_foreign") and html.transaction_valid():
if cls._bulk_delete_after_confirm("foreign") is False:
html.footer()
return
my_instances, foreign_instances, builtin_instances = cls.get_instances()
for what, title, instances in [
("my", _('Customized'), my_instances),
("foreign", _('Owned by other users'), foreign_instances),
("builtin", _('Builtin'), builtin_instances),
]:
if not instances:
continue
html.open_h3()
html.write(title)
html.close_h3()
if what != "builtin":
html.begin_form("bulk_delete_%s" % what, method="POST")
with table_element(limit=None) as table:
for instance in instances:
table.row()
if what != "builtin" and instance.may_delete():
table.cell(html.render_input(
"_toggle_group",
type_="button",
class_="checkgroup",
onclick="cmk.selection.toggle_all_rows(this.form);",
value='X'),
sortable=False,
css="checkbox")
html.checkbox("_c_%s+%s+%s" % (what, instance.owner(), instance.name()))
# Actions
table.cell(_('Actions'), css='buttons visuals')
# View
if isinstance(instance, PageRenderer):
html.icon_button(instance.page_url(), _("View"), "new_" + cls.type_name())
# Clone / Customize
html.icon_button(instance.clone_url(), _("Create a customized copy of this"),
"clone")
# Delete
if instance.may_delete():
html.icon_button(instance.delete_url(), _("Delete!"), "delete")
# Edit
if instance.may_edit():
html.icon_button(instance.edit_url(), _("Edit"), "edit")
cls.custom_list_buttons(instance)
# Internal ID of instance (we call that 'name')
table.cell(_('ID'), instance.name(), css="narrow")
# Title
table.cell(_('Title'))
html.write_text(instance.render_title())
html.help(_u(instance.description()))
# Custom columns specific to that page type
instance.render_extra_columns(table)
# ## for title, renderer in custom_columns:
# ## table.cell(title, renderer(visual))
# Owner
if instance.is_builtin():
ownertxt = html.render_i(_("builtin"))
else:
ownertxt = instance.owner()
table.cell(_('Owner'), ownertxt)
table.cell(_('Public'), _("yes") if instance.is_public() else _("no"))
table.cell(_('Hidden'), _("yes") if instance.is_hidden() else _("no"))
# FIXME: WTF?!?
# TODO: Haeeh? Another custom columns
# ## if render_custom_columns:
# ## render_custom_columns(visual_name, visual)
if what != "builtin":
html.button("_bulk_delete_%s" % what,
_("Bulk delete"),
"submit",
style="margin-top:10px")
html.hidden_fields()
html.end_form()
html.footer()
return
def _add_extra_form_sections(self):
forms.section(_('Editable by Users'))
html.help(_('It is possible to let users edit their custom attributes.'))
html.checkbox('user_editable',
self._attr.get('user_editable', True),
label=_("Users can change this attribute in their personal settings"))
def checkbox_component(htmlvar: str, value: FilterHTTPVariables, label: str):
html.open_nobr()
html.checkbox(htmlvar, bool(value.get(htmlvar)), label=label)
html.close_nobr()
def _activation_status(self):
with table_element("site-status",
searchable=False,
sortable=False,
css="activation") as table:
for site_id, site in sort_sites(activation_sites()):
table.row()
site_status, status = self._get_site_status(site_id, site)
is_online = self._site_is_online(status)
is_logged_in = self._site_is_logged_in(site_id, site)
has_foreign = self._site_has_foreign_changes(site_id)
can_activate_all = not has_foreign or user.may(
"wato.activateforeign")
# Disable actions for offline sites and not logged in sites
if not is_online or not is_logged_in:
can_activate_all = False
need_restart = self._is_activate_needed(site_id)
need_sync = self.is_sync_needed(site_id)
need_action = need_restart or need_sync
nr_changes = len(self._changes_of_site(site_id))
# Activation checkbox
table.cell("", css="buttons")
if can_activate_all and nr_changes:
html.checkbox("site_%s" % site_id,
need_action,
cssclass="site_checkbox")
# Iconbuttons
table.cell(_("Actions"), css="buttons")
if user.may("wato.sites"):
edit_url = watolib.folder_preserving_link([
("mode", "edit_site"), ("site", site_id)
])
html.icon_button(edit_url,
_("Edit the properties of this site"),
"edit")
# State
if can_activate_all and need_sync:
html.icon_button(
url="javascript:void(0)",
id_="activate_%s" % site_id,
cssclass="activate_site",
title=
_("This site is not update and needs a replication. Start it now."
),
icon="need_replicate",
onclick='cmk.activation.activate_changes("site", "%s")'
% site_id,
)
if can_activate_all and need_restart:
html.icon_button(
url="javascript:void(0)",
id_="activate_%s" % site_id,
cssclass="activate_site",
title=
_("This site needs a restart for activating the changes. Start it now."
),
icon="need_restart",
onclick='cmk.activation.activate_changes("site", "%s")'
% site_id,
)
if can_activate_all and not need_action:
html.icon("siteuptodate", _("This site is up-to-date."))
site_url = site.get("multisiteurl")
if site_url:
html.icon_button(
site_url,
_("Open this site's local web user interface"),
"url",
target="_blank",
)
table.cell(_("Site"),
site.get("alias", site_id),
css="narrow nobr")
# Livestatus
table.cell(_("Status"), css="narrow nobr")
html.status_label(content=status,
status=status,
title=_("This site is %s") % status)
# Livestatus-/Checkmk-Version
table.cell(_("Version"),
site_status.get("livestatus_version", ""),
css="narrow nobr")
table.cell(_("Changes"),
"%d" % nr_changes,
css="number narrow nobr")
table.cell(_("Progress"), css="repprogress")
html.open_div(id_="site_%s_status" % site_id, class_=["msg"])
html.close_div()
html.open_div(id_="site_%s_progress" % site_id,
class_=["progress"])
html.close_div()
table.cell(_("Details"), css="details")
html.open_div(id_="site_%s_details" % site_id)
last_state = self._last_activation_state(site_id)
if not is_logged_in:
html.write_text(_("Is not logged in.") + " ")
if not last_state:
html.write_text(_("Has never been activated"))
elif (need_action and last_state["_state"]
== cmk.gui.watolib.activate_changes.STATE_SUCCESS):
html.write_text(_("Activation needed"))
else:
html.javascript(
"cmk.activation.update_site_activation_state(%s);" %
json.dumps(last_state))
html.close_div()
