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 _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]))