def test_hook_filter_get_criteria(filter_fixtures):
"""
Test `prewikka.plugins.filter.filter.FilterView._filter_get_criteria` hook.
"""
# default
assert list(
hookmanager.trigger('HOOK_DATAPROVIDER_CRITERIA_PREPARE', 'alert'))
# env.request.menu = None
backup_menu = copy(env.request.menu)
env.request.menu = None
assert list(
hookmanager.trigger('HOOK_DATAPROVIDER_CRITERIA_PREPARE', 'alert'))
env.request.menu = backup_menu
# env.request.parameters.filter != None (invalid)
env.request.parameters['filter'] = 'foo'
assert list(
hookmanager.trigger('HOOK_DATAPROVIDER_CRITERIA_PREPARE', 'alert'))
# env.request.parameters.filter != None (valid)
filter_obj_1 = filter_fixtures.get('filter_obj_1')
env.request.parameters['filter'] = filter_obj_1.name
assert list(
hookmanager.trigger('HOOK_DATAPROVIDER_CRITERIA_PREPARE', 'alert'))
def render(self):
# FIXME: move theme management to a plugin !
if env.request.user:
theme = env.request.user.get_property(
"theme", default=env.config.general.default_theme)
lang = env.request.user.get_property(
"language", default=env.config.general.default_locale)
else:
theme = env.config.general.default_theme
lang = env.config.general.default_locale
_HEAD = copy.copy(_CSS_FILES)
_HEAD[resource.CSSLink("prewikka/css/themes/%s.css" % theme)] = True
_HEAD.update(_JS_FILES)
# The jqgrid locale files use only two characters for identifying the language (e.g. pt_BR -> pt)
_HEAD[resource.JSLink("prewikka/js/locales/grid.locale-%s.min.js" %
lang[:2])] = True
for contents in filter(None,
hookmanager.trigger("HOOK_LOAD_HEAD_CONTENT")):
_HEAD.update((i, True) for i in contents)
_BODY = utils.OrderedDict()
for contents in filter(None,
hookmanager.trigger("HOOK_LOAD_BODY_CONTENT")):
_BODY.update((i, True) for i in contents)
env.request.dataset["document"].head_content = _HEAD
env.request.dataset["document"].body_content = _BODY
env.request.dataset["toplayout_extra_content"] = filter(
None, hookmanager.trigger("HOOK_TOPLAYOUT_EXTRA_CONTENT"))
def agents(self):
analyzer_data = list(self._get_analyzers(env.request.parameters.getlist("status")))
list(hookmanager.trigger("HOOK_AGENTS_EXTRA_CONTENT", analyzer_data))
extra_columns = filter(None, hookmanager.trigger("HOOK_AGENTS_EXTRA_COLUMN"))
return view.ViewResponse(template.PrewikkaTemplate(__name__, "templates/agents.mak").render(data=analyzer_data, extra_columns=extra_columns), menu=mainmenu.HTMLMainMenu())
def agents(self, status=[]):
analyzer_data = list(self._get_analyzers(status))
list(hookmanager.trigger("HOOK_AGENTS_EXTRA_CONTENT", analyzer_data))
extra_columns = filter(None,
hookmanager.trigger("HOOK_AGENTS_EXTRA_COLUMN"))
return template.PrewikkaTemplate(__name__,
"templates/agents.mak").render(
data=analyzer_data,
extra_columns=extra_columns)
def modify(self):
self._object = user = usergroup.User(env.request.parameters.get("name", env.request.user.name))
if not env.request.parameters["language"] in localization.getLanguagesIdentifiers():
raise error.PrewikkaUserError(N_("Invalid Language"), N_("Specified language does not exist"), log_priority=log.WARNING)
list(hookmanager.trigger("HOOK_USERMANAGEMENT_USER_MODIFY", user))
if not env.request.parameters["timezone"] in localization.get_timezones():
raise error.PrewikkaUserError(N_("Invalid Timezone"), N_("Specified timezone does not exist"), log_priority=log.WARNING)
need_reload = False
user.begin_properties_change()
for param, reload in (("fullname", False), ("email", False), ("theme", True), ("language", True), ("timezone", False)):
if user == env.request.user and reload and env.request.parameters.get(param) != user.get_property(param):
need_reload = True
user.set_property(param, env.request.parameters.get(param))
if user == env.request.user:
user.set_locale()
user.commit_properties_change()
# Make sure nothing is returned (reset the default dataset)
env.request.dataset = None
if need_reload:
return response.PrewikkaDirectResponse({"type": "reload"})
return response.PrewikkaRedirectResponse(url_for(".display"), 303)
def _process_dynamic(self, webreq):
self._prewikka_init_if_needed()
# Some newly loaded plugin from another request may have modified globally loadeds
# JS/CSS scripts. We thus need to call _process_static() again after _prewikka_init_if_needed()
response = self._process_static(webreq)
if response:
return response
autherr = None
try:
env.request.user = env.session.get_user(webreq)
env.request.user.set_locale()
except error.PrewikkaError as autherr:
pass
if not all(
hookmanager.trigger("HOOK_PROCESS_REQUEST", webreq,
env.request.user)):
return
if webreq.path == "/":
return self._redirect_default(webreq)
try:
view_object = env.viewmanager.loadView(webreq, env.request.user)
except Exception as err:
raise autherr or err
if view_object.view_require_session and autherr:
view_object = autherr
resolve.process(env.dns_max_delay)
return view_object.respond()
def _toplayout_extra_content(self):
if env.request.user and not env.request.web.input_cookie.get(
"warning"):
env.request.web.add_cookie("warning", "warning",
365 * 24 * 60 * 60)
return next(hookmanager.trigger("HOOK_WARNING_CONTENT"),
[resource.HTMLSource(self._template.render())])
def render(self):
infos = {"host": self.parameters["host"]}
for info in hookmanager.trigger("HOOK_HOST_INFO", self.parameters["host"]):
infos.update(info)
return response.PrewikkaDirectResponse(json.dumps(list(self._link_generator(infos))))
def __init__(self, data_type):
self._enrich_data_cb = [
elem[1] for elem in sorted(
hookmanager.trigger(
"HOOK_DATASEARCH_FORMATTER_ENRICH_CALLBACK"))
]
self.type = data_type
def get_user(self, request):
info = self.get_user_info(request)
if not (info) or not (info.login) or self.autologin:
try:
login = self.__check_session(request)
except (SessionInvalid, SessionExpired):
if not self.autologin:
raise
else:
if not info or not info.login or login == info.login:
return usergroup.User(login)
else:
self.__delete_session(request)
user = self.authenticate(request, info)
self.__create_session(request, user)
list(hookmanager.trigger("HOOK_SESSION_CREATE", user))
is_admin = set(user.permissions) == usergroup.ALL_PERMISSIONS
env.log.info("User login with profile '%s'" %
("admin" if is_admin else "default"))
if "login_prevent_redirect" in env.request.web.arguments:
return user
raise RedirectionError(env.request.web.get_raw_uri(True), 303)
def render(self):
self.dataset["timeline"].order_by = env.request.parameters["orderby"]
self.dataset["timeline"].value = env.request.parameters["timeline_value"]
self.dataset["timeline"].unit = env.request.parameters["timeline_unit"]
self.dataset["timeline"].absolute = env.request.parameters["timeline_absolute"]
self.dataset["timeline"].quick_selected = _("Custom")
self.dataset["timeline"].quick_custom = True
self.dataset["timeline"].refresh_selected = _("Inactive")
self.dataset["auto_apply_value"] = env.request.parameters["auto_apply_value"]
self.dataset["timeline"].time_format = localization.get_calendar_format()
for label, value in self.dataset["timeline"].refresh:
if value == env.request.parameters["auto_apply_value"]:
self.dataset["timeline"].refresh_selected = label
if "timeline_start" not in env.request.parameters and "timeline_end" not in env.request.parameters:
for label, value, unit, absolute in self.dataset["timeline"].quick:
if value == env.request.parameters["timeline_value"] and unit == env.request.parameters["timeline_unit"] and absolute == env.request.parameters["timeline_absolute"]:
self.dataset["timeline"].quick_selected = label
self.dataset["timeline"].quick_custom = False
break
self._setup_timeline_range()
self._set_timeline(self.start, self.end)
self.dataset["menu_extra"] = filter(None, hookmanager.trigger("HOOK_MAINMENU_EXTRA_CONTENT", self._criteria_type))
def render(self):
self.parameters = env.request.parameters
self.dataset["timeline.order_by"] = self.parameters["orderby"]
self.dataset["timeline.value"] = self.parameters["timeline_value"]
self.dataset["timeline.unit"] = self.parameters["timeline_unit"]
self.dataset["timeline.absolute"] = self.parameters["timeline_absolute"]
self.dataset["timeline.quick_selected"] = _("Custom")
self.dataset["timeline.quick_custom"] = True
self.dataset["timeline.refresh_selected"] = _("Inactive")
self.dataset["auto_apply_value"] = self.parameters["auto_apply_value"]
self.dataset["auto_apply_enable"] = self.parameters["auto_apply_enable"]
self.dataset["timeline.time_format"] = localization.get_calendar_format()
for label, value in self.dataset["timeline.refresh"]:
if value == self.parameters["auto_apply_value"]:
self.dataset["timeline.refresh_selected"] = label
if "timeline_start" not in self.parameters and "timeline_end" not in self.parameters:
for label, value, unit, absolute in self.dataset["timeline.quick"]:
if value == self.parameters["timeline_value"] and unit == self.parameters["timeline_unit"] and absolute == self.parameters["timeline_absolute"]:
self.dataset["timeline.quick_selected"] = label
self.dataset["timeline.quick_custom"] = False
break
self._setup_timeline_range()
self._set_timeline(self.start, self.end)
self.dataset["menu_extra"] = itertools.ifilter(None, hookmanager.trigger("HOOK_MAINMENU_EXTRA_CONTENT", self._criteria_type))
def edit(self, name=None, widget=True):
group = None
if not name:
target = url_for(".create")
else:
group = usergroup.Group(name)
target = url_for(".save", name=name)
dset = self._setup_dataset(target, group)
if name:
if not env.request.user.has("GROUP_MANAGEMENT"):
raise error.PrewikkaUserError(
_("Permission Denied"),
N_("Access denied to group settings"),
log_priority=log.WARNING)
permissions = env.auth.get_group_permissions(group)
dset["permissions"] = []
for perm in sorted(usergroup.ACTIVE_PERMISSIONS):
dset["permissions"].append((perm, perm in permissions, False))
dset["widget"] = widget
dset["extra_content"] = filter(
None,
hookmanager.trigger("HOOK_GROUPMANAGEMENT_EXTRA_CONTENT", group,
"group"))
return dset.render()
def save(self, name):
group = usergroup.Group(name)
list(hookmanager.trigger("HOOK_GROUPMANAGEMENT_GROUP_MODIFY", group))
old_permissions = env.auth.get_group_permissions(group)
permissions = self._make_permissions_from_parameters(old_permissions)
self.log_property_list_change("permissions", group, old_permissions,
permissions)
env.auth.set_group_permissions(group, permissions)
if env.auth.is_member_of(group, env.request.user):
env.request.user.permissions = env.auth.get_user_permissions(
env.request.user)
# Group memberships
if env.auth.can_manage_group_members():
users = set(
usergroup.User(i)
for i in env.request.parameters.getlist("member_object"))
self.log_property_list_change("users", group,
env.auth.get_group_members(group),
users)
env.auth.set_group_members(group, users)
return response.PrewikkaResponse({
"type": "reload",
"target": ".commonlisting"
})
def _register_parameters(view_parameters):
view_parameters.optional("timeline_mode",
text_type,
default="relative",
save=True,
general=True)
view_parameters.optional("timeline_value",
int,
default=1,
save=True,
general=True)
view_parameters.optional("timeline_unit",
text_type,
default="month",
save=True,
general=True)
view_parameters.optional("timeline_offset",
int,
default=0,
save=True,
general=True)
view_parameters.optional("timeline_end", int, save=True, general=True)
view_parameters.optional("timeline_start", int, save=True, general=True)
view_parameters.optional("auto_apply_value",
int,
default=0,
save=True,
general=True)
view_parameters.MAINMENU_PARAMETERS = _MAINMENU_PARAMETERS[:]
for i in hookmanager.trigger("HOOK_MAINMENU_PARAMETERS_REGISTER",
view_parameters):
view_parameters.MAINMENU_PARAMETERS.extend(i)
def _normalize(self, type, paths=None, criteria=None):
if paths is None:
paths = []
if criteria is None:
criteria = Criterion()
else:
criteria = copy.copy(criteria)
type = self._check_data_type(type, paths, criteria)
parsed_paths = paths
parsed_criteria = None
paths_types = []
normalizer = self._type_handlers[type].normalizer
for c in filter(
None,
hookmanager.trigger("HOOK_DATAPROVIDER_CRITERIA_PREPARE",
type)):
criteria += c
if normalizer:
paths = normalizer.format_paths(paths, type)
parsed_paths, paths_types = normalizer.parse_paths(paths, type)
if criteria:
parsed_criteria = normalizer.parse_criteria(criteria, type)
return AttrObj(type=type,
paths=paths,
parsed_paths=parsed_paths,
paths_types=paths_types,
parsed_criteria=parsed_criteria)
def _render(self):
mode = self.dataset["timeline"].mode = self._parameters[
"timeline_mode"]
self.dataset["auto_apply_value"] = self._parameters["auto_apply_value"]
self.dataset["timeline"].value = self._parameters["timeline_value"]
self.dataset["timeline"].unit = self._parameters["timeline_unit"]
self.dataset["timeline"].offset = self._parameters["timeline_offset"]
self.dataset[
"timeline"].time_format = localization.get_calendar_format()
self.dataset["timeline"].refresh_selected = self.dataset[
"timeline"].refresh.get(self._parameters["auto_apply_value"],
_("Inactive"))
if mode == "custom":
self.dataset["timeline"].quick_selected = _("Custom")
else:
wanted = (self._parameters["timeline_value"],
self._parameters["timeline_unit"], mode == "absolute",
self._parameters["timeline_offset"])
self.dataset["timeline"].quick_selected = self.dataset[
"timeline"].quick.get(wanted, _("None"))
self._setup_timeline_range()
self._set_timeline(self.start, self.end)
self.dataset["mainmenu_url"] = url_for("BaseView.mainmenu",
datatype=self._criteria_type)
if "menu_extra" not in self.dataset:
self.dataset["menu_extra"] = filter(
None,
hookmanager.trigger("HOOK_MAINMENU_EXTRA_CONTENT",
self._criteria_type,
parameters=self._parameters,
**self.dataset))
def _replace(self, element):
element = element.group(1)
if element in ("and", "AND", "&&"):
return "&&"
if element in ("or", "OR", "||"):
return "||"
if not element in self.elements:
raise error.PrewikkaUserError(
_("Invalid filter element"),
N_("Invalid filter element '%s' referenced from filter formula", element))
prev_val = self.elements[element][2]
elements = self.elements[element]
for i in hookmanager.trigger("HOOK_FILTER_CRITERIA_LOAD", elements):
if i:
elements = i
criteria, operator, value = elements
if value == prev_val:
value = "'%s'" % utils.escape_criteria(utils.filter_value_adjust(operator, value))
if self.type:
criteria = ".".join((self._typetbl[self.type], criteria))
return "%s %s (%s)" % (criteria, operator, value)
def render(self):
infos = {"host": env.request.parameters["host"]}
for info in hookmanager.trigger("HOOK_HOST_INFO", env.request.parameters["host"]):
infos.update(info)
return response.PrewikkaDirectResponse(list(self._link_generator(infos)))
def test_hook_filter_param_register(filter_fixtures):
"""
Test `prewikka.plugins.filter.filter.FilterView._filter_parameters_register` hook.
"""
assert list(
hookmanager.trigger('HOOK_MAINMENU_PARAMETERS_REGISTER',
env.request.parameters))
def render(self):
infos = []
for info in hookmanager.trigger("HOOK_HOST_TOOLTIP",
env.request.parameters["host"]):
infos.extend(info)
return infos
def createHostField(self,
object,
value,
category=None,
direction=None,
dns=True):
field = self.createInlineFilteredField(object, value, direction)
field["host_links"] = []
field["category"] = category
field["url_infos"] = url_for(
"HostInfoAjax", host=value
) if value and "HOOK_HOST_TOOLTIP" in hookmanager.hookmgr else None
field["url_popup"] = url_for("AjaxHostURL",
host=value) if value else None
if value and dns is True:
field["hostname"] = resolve.AddressResolve(value)
else:
field["hostname"] = value or _("n/a")
if not value:
return field
for typ, linkname, link, widget in hookmanager.trigger(
"HOOK_LINK", value):
if typ == "host":
field["host_links"].append((linkname, link, widget))
return field
def normalize(self, view_name, user):
do_load = view.Parameters.normalize(self, view_name, user)
if self["orderby"] not in ("time_desc", "time_asc", "count_desc", "count_asc"):
raise view.InvalidParameterValueError("orderby", self["orderby"])
all(hookmanager.trigger("HOOK_MAINMENU_PARAMETERS_NORMALIZE", self))
return do_load
def normalize(self, view_name, user):
do_load = view.Parameters.normalize(self, view_name, user)
if self["orderby"] not in ("time_desc", "time_asc", "count_desc", "count_asc"):
raise view.InvalidParameterValueError("orderby", self["orderby"])
all(hookmanager.trigger("HOOK_MAINMENU_PARAMETERS_NORMALIZE", self))
return do_load
def _loadPlugins(self):
env.menumanager = menu.MenuManager()
env.dataprovider = dataprovider.DataProviderManager()
env.dataprovider.load()
env.viewmanager = view.ViewManager()
env.plugins = {}
for i in pluginmanager.PluginManager("prewikka.plugins"):
try:
env.plugins[i.__name__] = i()
except error.PrewikkaUserError as err:
env.log.warning("%s: plugin loading failed: %s" %
(i.__name__, err))
# Load views before auth/session to find all permissions
env.viewmanager.loadViews()
_AUTH_PLUGINS = pluginmanager.PluginManager("prewikka.auth",
autoupdate=True)
_SESSION_PLUGINS = pluginmanager.PluginManager("prewikka.session",
autoupdate=True)
cfg = env.config
if cfg.session:
self._load_auth_or_session("session", _SESSION_PLUGINS,
cfg.session.get_instance_name(),
cfg.session)
if isinstance(env.session, auth.Auth):
# If the session module is also an auth module, no need to load an auth module
env.auth = env.session
if cfg.auth:
env.log.error(
_("Session '%s' does not accept any authentication module"
% cfg.session.get_instance_name()))
else:
# If no authentification module defined, we use the session's default auth module
auth_name = cfg.auth.get_instance_name(
) if cfg.auth else env.session.get_default_auth()
self._load_auth_or_session("auth", _AUTH_PLUGINS, auth_name,
cfg.auth)
elif cfg.auth:
# No session module defined, we load the auth module first
self._load_auth_or_session("auth", _AUTH_PLUGINS,
cfg.auth.get_instance_name(), cfg.auth)
self._load_auth_or_session("session", _SESSION_PLUGINS,
env.auth.getDefaultSession())
else:
# Nothing defined, we use the anonymous module
self._load_auth_or_session("session", _SESSION_PLUGINS,
"anonymous")
env.auth = env.session
env.viewmanager.addView(viewhelpers.AjaxHostURL())
if env.session.can_logout():
env.viewmanager.addView(Logout())
env.renderer = renderer.RendererPluginManager()
list(hookmanager.trigger("HOOK_PLUGINS_LOAD"))
def test_filter_html_menu(filter_fixtures):
"""
Test `prewikka.plugins.filter.filter.FilterView._filter_html_menu` hook.
"""
assert list(
hookmanager.trigger('HOOK_MAINMENU_EXTRA_CONTENT',
'alert',
env.request.parameters,
input_size="md"))
def buildAdditionalData(self, alert, ignore=[], ignored={}, ip_options=[], tcp_options=[]):
self.beginSection(_("Additional data"))
self.beginTable()
self.newTableCol(0, _("Meaning"), header=True)
self.newTableCol(0, _("Value"), header=True)
index = 1
for ad in alert["additional_data"]:
value = None
meaning = ad["meaning"]
if meaning == "ip_option_code":
ip_options.append((ad["data"], 0, None))
ignored[meaning] = ""
if meaning == "ip_option_data":
data = ad["data"]
ip_options[-1] = (ip_options[-1][0], len(data), data)
ignored[meaning] = ""
if meaning == "tcp_option_code":
tcp_options.append((ad["data"], 0, None))
ignored[meaning] = ""
if meaning == "tcp_option_data":
data = ad["data"]
tcp_options[-1] = (tcp_options[-1][0], len(data), data)
ignored[meaning] = ""
if ad["data"] != None:
value = ad["data"]
if ad["type"] == "byte-string" and meaning != "payload":
value = utils.hexdump(value)
for field in ignore:
if meaning != None and meaning == field[0]:
ignored[meaning] = value
break
links = []
for url, text in hookmanager.trigger("HOOK_ALERTSUMMARY_MEANING_LINK", alert, meaning, value):
if url:
links.append("<a target='%s' href='%s'>%s</a>" % \
(env.external_link_target, url, text))
if links:
meaning = "<a class='popup_menu_toggle'>%s</a><span class='popup_menu'>%s</span>" % \
(meaning, "".join(links))
if not ignored.has_key(meaning):
self.newTableCol(index, meaning or "Data content")
self.newTableCol(index, utils.escape_html_string(value) if value is not None else None)
index += 1
self.endTable()
self.endSection()
def normalize(self):
do_update = self._save and env.request.web.method == "PATCH"
do_save = self._save and env.request.web.method in ("POST", "PUT",
"PATCH")
for name, value in self.items():
param = self._parameters.get(name)
if not param:
if not (self.allow_extra_parameters):
raise InvalidParameterError(name)
continue
value = param.parse(value)
if env.request.user and param.save and do_save:
env.request.user.set_property(
name, value,
self.view.view_endpoint if not (param.general) else None)
self[name] = value
# Go through unset parameters.
# - Error out on mandatory parameters,
# - Load default value for optional parameters that got one.
# - Load last user value for parameter.
for name in set(self._parameters.keys()) - set(self.keys()):
param = self._parameters[name]
if param.mandatory:
raise MissingParameterError(name)
elif param.has_default():
self[name] = param.default
if not param.save or not env.request.user:
continue
if param.general:
save_view = ""
else:
save_view = self.view.view_endpoint
if do_save and not (param.persist) and not do_update:
env.request.user.del_property(name, view=save_view)
if name not in env.request.user.configuration.get(save_view, {}):
continue
value = env.request.user.get_property(name, view=save_view)
self._default[name] = value
self[name] = value
# In case the view was dynamically added through HOOK_VIEW_LOAD, the hook isn't available
list(
hookmanager.trigger(
"HOOK_%s_PARAMETERS_NORMALIZE" %
self.view.view_endpoint.upper(), self))
def _load_plugins(self):
env.pluginmanager = {}
env.all_plugins = {}
env.menumanager = menu.MenuManager()
env.dataprovider = dataprovider.DataProviderManager(
autoupdate=self.autoupdate)
env.dataprovider.load()
env.linkmanager = link.LinkManager()
env.plugins = {}
pluginmanager.SimplePluginManager("prewikka.plugins",
autoupdate=self.autoupdate).load()
# Load views before auth/session to find all permissions
env.viewmanager.load_views(autoupdate=self.autoupdate)
_AUTH_PLUGINS = pluginmanager.PluginManager("prewikka.auth",
autoupdate=True)
_SESSION_PLUGINS = pluginmanager.PluginManager("prewikka.session",
autoupdate=True)
cfg = env.config
if cfg.session:
self._load_auth_or_session("session", _SESSION_PLUGINS,
cfg.session.get_instance_name(),
cfg.session)
if isinstance(env.session, auth.Auth):
# If the session module is also an auth module, no need to load an auth module
env.auth = env.session
if cfg.auth:
env.log.error(
_("Session '%s' does not accept any authentication module"
% cfg.session.get_instance_name()))
else:
# If no authentification module defined, we use the session's default auth module
auth_name = cfg.auth.get_instance_name(
) if cfg.auth else env.session.get_default_auth()
self._load_auth_or_session("auth", _AUTH_PLUGINS, auth_name,
cfg.auth)
elif cfg.auth:
# No session module defined, we load the auth module first
self._load_auth_or_session("auth", _AUTH_PLUGINS,
cfg.auth.get_instance_name(), cfg.auth)
self._load_auth_or_session("session", _SESSION_PLUGINS,
env.auth.get_default_session())
else:
# Nothing defined, we use the anonymous module
self._load_auth_or_session("session", _SESSION_PLUGINS,
"anonymous")
env.auth = env.session
env.renderer = renderer.RendererPluginManager(
autoupdate=self.autoupdate)
env.renderer.load()
list(hookmanager.trigger("HOOK_PLUGINS_LOAD"))
def get_filters(self, user, ftype=None):
l = self.query("SELECT name, description, value FROM Prewikka_Filter "
"WHERE userid = %s", user.id)
l = next(hookmanager.trigger("HOOK_FILTER_LISTING", l), l)
for name, description, value in l:
criteria = json.loads(value)
if not ftype or ftype in criteria:
yield Filter(name, description, criteria)
def logout(self, request):
login = self.__check_session(request)
self.__delete_session(request)
list(hookmanager.trigger("HOOK_SESSION_DELETE", usergroup.User(login)))
env.log.info("Logged out")
raise SessionInvalid(message=N_("Logged out"),
login=login,
log_priority=log.INFO,
template=self.template)
def _prepare(self, dataset):
# FIXME: move theme management to a plugin !
if env.request.user:
theme = env.request.user.get_property(
"theme", default=env.config.general.default_theme)
lang = env.request.user.get_property(
"language", default=env.config.general.default_locale)
else:
theme = env.config.general.default_theme
lang = env.config.general.default_locale
_HEAD = collections.OrderedDict(
(resource.CSSLink(link), True) for link in CSS_FILES)
_HEAD[resource.CSSLink("prewikka/css/themes/%s.css" % theme)] = True
_HEAD.update((resource.JSLink(link), True) for link in JS_FILES)
# The jqgrid locale files use only two characters for identifying the language (e.g. pt_BR -> pt)
_HEAD[resource.JSLink("prewikka/js/locales/jqgrid/grid.locale-%s.js" %
lang[:2])] = True
_HEAD[resource.JSLink("prewikka/js/locales/select2/%s.js" %
lang[:2])] = True
for contents in filter(None,
hookmanager.trigger("HOOK_LOAD_HEAD_CONTENT")):
_HEAD.update((i, True) for i in contents)
_BODY = collections.OrderedDict()
for contents in filter(None,
hookmanager.trigger("HOOK_LOAD_BODY_CONTENT")):
_BODY.update((i, True) for i in contents)
if not dataset: # In case of error, we use the exception dataset
dataset = _BASEVIEW_TEMPLATE.dataset()
self._setup_dataset_default(dataset)
dataset["document"].head_content = _HEAD
dataset["document"].body_content = _BODY
dataset["document"].lang = lang[:2]
dataset["toplayout_extra_content"] = filter(
None, hookmanager.trigger("HOOK_TOPLAYOUT_EXTRA_CONTENT"))
return dataset.render()
def get_sections(self, user=None):
def _merge(d1, d2):
for section, tabs in d2.items():
d1[section] = copy(d1.get(section, {}))
for tab, views in tabs.items():
d1[section][tab] = views
d = copy(self._loaded_sections)
[_merge(d, i) for i in hookmanager.trigger("HOOK_MENU_LOAD", user) if i]
return d
def preprocess_value(self, value):
if value is None:
return None
if self._parent._paths_types:
value = self._cast(value)
cont = [self._get_current_path(), value]
list(hookmanager.trigger("HOOK_DATAPROVIDER_VALUE_READ", cont))
return cont[1]
def get(self, key, default=None):
value = self._obj.get(key)
if value is None:
return default
curpath = self._curpath + [key]
cont = [".".join(curpath), self.preprocess_value(value)]
list(hookmanager.trigger("HOOK_DATAPROVIDER_VALUE_READ", cont))
return self._wrapobj(cont[1], curpath)
def test_hookmanager_unregister():
"""
Test `prewikka.hookmanager.HookManager.unregister()` method.
"""
hook = 'hook_6'
method = lambda x: x
hookmanager.register(hook, method)
hookmanager.unregister(hook, method)
assert list(hookmanager.trigger(hook, 'bar')) == []
def render(self):
# FIXME: move theme management to a plugin !
if env.request.user:
theme = env.request.user.get_property("theme", default=env.config.general.default_theme)
lang = env.request.user.get_property("language", default=env.config.general.default_locale)
else:
theme = env.config.general.default_theme
lang = env.config.general.default_locale
# The jqgrid locale files use only two characters for identifying the language (e.g. pt_BR -> pt)
lang_file = resource.JSLink("prewikka/js/locales/grid.locale-%s.js" % lang[:2])
theme_file = resource.CSSLink("prewikka/css/themes/%s.css" % theme)
head = _CSS_FILES + [theme_file] + _JS_FILES + [lang_file]
for i in hookmanager.trigger("HOOK_LOAD_HEAD_CONTENT"):
head += (content for content in i if content not in head)
self.dataset["document.head_content"] = head
self.dataset["toplayout_extra_content"] = ""
list(hookmanager.trigger("HOOK_TOPLAYOUT_EXTRA_CONTENT", self.dataset))
def __init__(self, view, *args, **kwargs):
dict.__init__(self, *args, **kwargs)
self._hard_default = {}
self._default = {}
self._parameters = { }
self.register()
self.optional("_save", str)
self.optional("_download", str)
list(hookmanager.trigger("HOOK_%s_PARAMETERS_REGISTER" % view.view_id.upper(), self))
def register(self):
view.Parameters.register(self)
self.optional("timeline_value", int, default=1, save=True, general=True)
self.optional("timeline_unit", str, default="month", save=True, general=True)
self.optional("timeline_absolute", int, default=0, save=True, general=True)
self.optional("timeline_end", long, save=True, general=True)
self.optional("timeline_start", long, save=True, general=True)
self.optional("orderby", str, "time_desc")
self.optional("auto_apply_value", int, default=0, save=True, general=True)
self.optional("auto_apply_enable", str, default="false", save=True, general=True)
for i in hookmanager.trigger("HOOK_MAINMENU_PARAMETERS_REGISTER", self):
self._INTERNAL_PARAMETERS = self._INTERNAL_PARAMETERS + i
def get_filter_list(self, user, ftype=None, name=None):
type_str=""
if ftype:
type_str = " AND (type = %s OR type = 'generic')" % self.escape(ftype)
l = map(lambda r: r[0], self.query("SELECT name FROM Prewikka_Filter WHERE userid = %s%s%s" % (self.escape(user.id), type_str, self._chk("name", name))))
for i in hookmanager.trigger("HOOK_FILTER_LISTING", l):
if i is not None:
l = i
continue
return l
def _prepare_criteria(self, criteria, criteria_type):
if not criteria:
criteria = []
if type(criteria) is not list:
criteria = [ criteria ]
all(hookmanager.trigger("HOOK_IDMEFDATABASE_CRITERIA_PREPARE", criteria, criteria_type))
# Do not use string formatting to avoid errors when criteria contains '%'
criteria = " && ".join(criteria).replace("%(backend)s", criteria_type).replace("%(time_field)s", "create_time")
if len(criteria) > 0:
return prelude.IDMEFCriteria(criteria)
return None
def createHostField(self, object, value, category=None, direction=None, dns=True):
field = self.createInlineFilteredField(object, value, direction)
field["host_links"] = [ ]
field["category"] = category
field["url_infos"] = utils.create_link("hostinfoajax", {"host": value}) if "HOOK_HOST_TOOLTIP" in hookmanager.hookmgr else None
field["url_popup"] = utils.create_link("AjaxHostURL", {"host": value})
if value and dns is True:
field["hostname"] = resolve.AddressResolve(value)
else:
field["hostname"] = value or _("n/a")
if not value:
return field
for typ, linkname, link, widget in hookmanager.trigger("HOOK_LINK", value):
if typ == "host":
field["host_links"].append((linkname, link, widget))
return field
def process(self, webreq):
env.request.init(webreq)
view_object = autherr = None
encoding = env.config.general.get("encoding", "utf8")
try:
self._prewikka_init_if_needed()
try:
env.request.user = env.session.get_user(webreq)
env.request.user.set_locale()
except Exception as autherr:
pass
if not all(hookmanager.trigger("HOOK_PROCESS_REQUEST", webreq, env.request.user)):
return
if webreq.path == "/":
return self._redirect_default(webreq)
view_object = env.viewmanager.loadView(webreq, env.request.user)
if view_object.view_require_session and autherr:
raise autherr
resolve.process(env.dns_max_delay)
response = view_object.respond()
except error.RedirectionError as err:
return webreq.send_redirect(err.location, err.code)
except error.PrewikkaUserError as err:
response = err.respond()
except Exception, err:
response = error.PrewikkaUserError(
_("Prelude internal error"),
err,
display_traceback=env.config.general.get("enable_error_traceback") not in ('no', 'false')
).respond()
def loadView(self, request, userl):
view = view_layout = None
view_id = self.getViewID(request)
if view_id:
view = self.getView(view_id)
else:
view = next((x for x in hookmanager.trigger("HOOK_VIEW_LOAD", request, userl) if x), None)
if view:
view_layout = view.view_layout
if not request.is_xhr and not request.is_stream and view_layout and not "_download" in request.arguments:
view = self.getView(view_layout)
if not view:
raise InvalidViewError(N_("View '%s' does not exist", request.path))
if userl and view.view_permissions and not userl.has(view.view_permissions):
raise usergroup.PermissionDeniedError(view.view_permissions, view.view_id)
return copy(view)
def render(self):
analyzer_data = list(self._get_analyzers())
list(hookmanager.trigger("HOOK_AGENTS_EXTRA_CONTENT", analyzer_data))
self.dataset["data"] = utils.escape_attribute(json.dumps(analyzer_data))
self.dataset["extra_columns"] = [col for col in hookmanager.trigger("HOOK_AGENTS_EXTRA_COLUMN") if col]
def deleteGroup(self, group):
list(hookmanager.trigger("HOOK_GROUP_DELETE", group))
def createGroup(self, group):
list(hookmanager.trigger("HOOK_GROUP_CREATE", group))
def deleteUser(self, user):
list(hookmanager.trigger("HOOK_USER_DELETE", user))
env.db.del_properties(user)
def createUser(self, user):
list(hookmanager.trigger("HOOK_USER_CREATE", user))
def render(self):
infos = []
for info in hookmanager.trigger("HOOK_HOST_TOOLTIP", self.parameters["host"]):
infos.extend(info)
return infos
def normalize(self, view, user):
do_load = True
do_save = "_save" in self
for name, value in self.items():
param = self._parameters.get(name)
if not param:
if not(self.allow_extra_parameters):
raise InvalidParameterError(name)
continue
if not name in self._parameters or param.mandatory is False:
do_load = False
value = param.parse(value)
if user and param.save and do_save:
if param.general:
user.set_property(name, value)
else:
user.set_property(name, value, view=view)
self[name] = value
# Go through unset parameters.
# - Error out on mandatory parameters,
# - Load default value for optional parameters that got one.
# - Load last user value for parameter.
for name in set(self._parameters.keys()) - set(self.keys()):
param = self._parameters[name]
if param.mandatory:
raise MissingParameterError(name)
elif param.has_default():
self[name] = param.default
if not param.save or not user:
continue
if param.general:
save_view = None
else:
save_view = view
if do_save:
user.del_property(name, view=save_view)
else:
if not name in user.configuration.get(save_view, {}):
continue
value = param.parse(user.get_property(name, view=save_view))
self._default[name] = value
if do_load:
self[name] = value
# In case the view was dynamically added through HOOK_VIEW_LOAD, the hook isn't available
list(hookmanager.trigger("HOOK_%s_PARAMETERS_NORMALIZE" % view.upper(), self))
self.pop("_save", None)
return do_load
def _filter_delete(self, user, name):
idlist = self._db.delete_filter(user, name)
list(hookmanager.trigger("HOOK_FILTER_DELETE", user, name, idlist[0]))
