def listing(self): dataset = {} data = [] for fltr in self._db.get_filters(env.request.user): elem = { "id": fltr.id_, "name": resource.HTMLNode("a", fltr.name, href=url_for(".edit", name=fltr.name), title=_("Filter %s") % fltr.name), "category": fltr.category, "description": fltr.description } for typ in fltr.criteria: elem[typ] = True data.append(elem) dataset["data"] = data dataset["columns"] = self._get_types() return template.PrewikkaTemplate( __name__, "templates/filterlisting.mak").render(**dataset)
def edit(self, name=None): id_ = env.request.parameters.get("duplicate", type=int) dataset = { "fltr": AttrObj(id_=None, name=None, category=None, description=None, criteria={}), "categories": self._db.get_categories(env.request.user), "types": list(self._get_types()) } if name or id_: dataset["fltr"] = self._db.get_filter(env.request.user, name, id_) if not dataset["fltr"]: raise error.PrewikkaUserError( N_("Filter error"), N_("Filter '%s' does not exist", name or id_)) dataset["fltr"].criteria = dataset["fltr"].flatten_criteria() if "duplicate" in env.request.parameters: dataset["fltr"].name = None return template.PrewikkaTemplate( __name__, "templates/filteredition.mak").render(**dataset)
class LoginFormSession(session.Session): plugin_name = "Login authentication" plugin_author = version.__author__ plugin_license = version.__license__ plugin_version = version.__version__ plugin_copyright = version.__copyright__ plugin_description = N_("Login/Password authentication") plugin_htdocs = (("loginform", pkg_resources.resource_filename(__name__, 'htdocs')), ) template = template.PrewikkaTemplate(__name__, 'templates/loginform.mak') def get_user_info(self, request): login = request.arguments.pop("_login", None) if not login: return None return session.SessionUserInfo(login, request.arguments.pop("_password", "")) def logout(self, request): return session.Session.logout(self, request) def get_default_auth(self): return "dbauth"
def render(self): idmef_class = env.request.parameters.get("idmef_class", "IDMEF-Message") dataset = {} if idmef_class not in self.schema: raise error.PrewikkaUserError( N_("Parameter Error"), N_("%(idmefclass)s is not a valid IDMEF class", {'idmefclass': idmef_class})) dataset["schema"] = self.schema[idmef_class] dataset["full_schema"] = self.schema dataset["link"] = self.view_path with open("%s/graph/%s.svg" % (self._HTDOCS_DIR, idmef_class), 'r') as stream: dataset["svg"] = re.sub(r"\d+pt", "100%", stream.read()) with open("%s/graph/%s" % (self._HTDOCS_DIR, idmef_class), 'r') as stream: dataset["dot"] = stream.read() dataset["png"] = "idmefnav/graph/%s.png" % idmef_class return template.PrewikkaTemplate( __name__, "templates/idmefnav.mak").render(**dataset)
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 edit(self, id=None): dataset = template.PrewikkaTemplate(__name__, "templates/cronjob.mak").dataset() dataset["job"] = crontab.get(id) return dataset.render()
def render(self): return template.PrewikkaTemplate( __name__, "templates/customcss.mak").render( less_variables=_LESS_VARIABLES, current_theme=env.request.user.get_property("theme", default="cs"), themes=theme.get_themes())
def _toplayout_extra_content(self): # Don't show the risk overview if the user is not logged in if not env.request.user: return return resource.HTMLSource( template.PrewikkaTemplate(__name__, "templates/riskoverview.mak").render())
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 _get_common_infos(self): tmpl = template.PrewikkaTemplate(__name__, "templates/infos.mak") query = self.query_parser(env.request.parameters["query"], groupby=[env.request.parameters["field"]], limit=5, parent=self) occurrences = [(value, count) for count, value in query.get_result()] return tmpl.dataset(selected_field=env.request.parameters["field"], selected_occur=occurrences).render()
def render_get(self): dset = template.PrewikkaTemplate( __name__, "templates/aboutplugin.mak").dataset() data = self._get_plugin_infos() dset["installed"] = data.installed dset["maintenance"] = data.maintenance dset["maintenance_total"] = data.maintenance_total return dset.render()
def render(self): idmef_class = env.request.parameters.get("idmef_class", "IDMEF-Message") if idmef_class not in self.schema: raise view.InvalidParameterValueError("idmef_class", idmef_class) dset = template.PrewikkaTemplate(__name__, "templates/idmefnav.mak").dataset() dset["schema"] = self.schema[idmef_class] dset["schema"]['svg'] = dset["schema"]['svg'].replace(graph_generator._LINK_TAG, url_for('idmefnav.render')) dset["full_schema"] = self.schema return dset.render()
def ajax_details(self): obj = env.dataprovider.get( utils.json.loads(env.request.parameters["_criteria"]))[0] out = {} self._recurse_idmef(out, obj) return response.PrewikkaResponse( template.PrewikkaTemplate( __name__, "templates/details.mak").dataset(fields_info=sorted( out.keys(), key=utils.path_sort_key), fields_value=out))
def render(self): extra_url = "" if env.request.parameters: if 'extra_url' in env.request.parameters: extra_url = "/" + env.request.parameters.pop('extra_url') extra_url += "?" + utils.urlencode(env.request.parameters) dataset = template.PrewikkaTemplate( __name__, "templates/custom.mak").dataset(custom_url=self._view_url + extra_url) return dataset.render()
class Warning(view.View): plugin_name = "Warning" plugin_author = version.__author__ plugin_license = version.__license__ plugin_version = version.__version__ plugin_copyright = version.__copyright__ plugin_description = N_("Prelude Warning message") _template = template.PrewikkaTemplate(__name__, "templates/warning.mak") @hookmanager.register("HOOK_LOAD_BODY_CONTENT") def _toplayout_extra_content(self): if not env.request.web.input_cookie.get("sessionid"): return [ resource.HTMLSource(self._template.render()) ]
class HeartbeatListing(MessageListing): view_menu = (N_("Agents"), N_("Heartbeats")) view_parameters = HeartbeatListingParameters view_permissions = [N_("IDMEF_VIEW")] view_template = template.PrewikkaTemplate(__name__, "templates/heartbeatlisting.mak") view_extensions = (("menu", mainmenu.MainMenuHeartbeat),) root = "heartbeat" filters = {} listed_heartbeat = ListedHeartbeat def _setMessage(self, message, ident): msg = self.listed_heartbeat(self.view_path, env.request.parameters) msg.setMessage(message, ident) return msg def _applyInlineFilters(self, criteria): for column, path in (("analyzerid", "heartbeat.analyzer(-1).analyzerid"), ("name", "heartbeat.analyzer(-1).name"), ("model", "heartbeat.analyzer(-1).model"), ("address", "heartbeat.analyzer(-1).node.address.address"), ("node_name", "heartbeat.analyzer(-1).node.name")): env.request.dataset[column + "_filtered"] = False if path in env.request.parameters: criteria += Criterion(path, "=", env.request.parameters[path]) env.request.dataset[column + "_filtered"] = True def render(self): MessageListing.render(self) criteria = env.request.menu.get_criteria() self._applyInlineFilters(criteria) self._adjustCriteria(criteria) self._updateMessages(env.dataprovider.delete, criteria) self._setNavPrev(env.request.parameters["offset"]) count = self._setMessages(criteria) env.request.dataset["nav"]["from"] = localization.format_number(env.request.parameters["offset"] + 1) env.request.dataset["nav"]["to"] = localization.format_number(env.request.parameters["offset"] + len(env.request.dataset["messages"])) env.request.dataset["limit"] = localization.format_number(env.request.parameters["limit"]) env.request.dataset["total"] = localization.format_number(count) self._setNavNext(env.request.parameters["offset"], count)
def __init__(self): _ViewDescriptor.__init__(self) if self.view_template and not isinstance(self.view_template, template.PrewikkaTemplate): self.view_template = template.PrewikkaTemplate(self.view_template) if not self.view_id: self.view_id = self.__class__.__name__.lower() if not self.view_path: if self.view_menu: self.view_path = "/" + "/".join(self.view_menu) if self.view_path: self.view_path = utils.nameToPath(self.view_path)
def edit(self, name=None): if "duplicate" in env.request.parameters: name = env.request.parameters["duplicate"] dataset = { "fltr": AttrObj(name="", description="", criteria={}), "types": list(self._get_types()) } if name: dataset["fltr"] = self._db.get_filter(env.request.user, name) dataset["fltr"].criteria = dataset["fltr"].flatten_criteria() if "duplicate" in env.request.parameters: dataset["fltr"].name = None return template.PrewikkaTemplate(__name__, "templates/filteredition.mak").render(**dataset)
def display(self): self._object = env.request.user if not env.auth.hasUser(self._object): raise error.PrewikkaUserError(N_("Invalid User"), N_("Requested user '%s' does not exist", self._object)) dataset = {} dataset["object"] = self._object dataset["fullname"] = self._object.get_property("fullname") dataset["email"] = self._object.get_property("email") dataset["available_timezones"] = localization.get_timezones() dataset["timezone"] = self._object.get_property("timezone", default=env.config.general.default_timezone) dataset["available_languages"] = localization.getLanguagesAndIdentifiers() dataset["language"] = self._object.get_property("language", default=env.config.general.default_locale) dataset["available_themes"] = theme.getThemes() dataset["selected_theme"] = self._object.get_property("theme", default=env.config.general.default_theme) return template.PrewikkaTemplate(__name__, 'templates/usersettings.mak').render(**dataset)
class Warning(view.View): plugin_name = "Warning" plugin_author = version.__author__ plugin_license = version.__license__ plugin_version = version.__version__ plugin_copyright = version.__copyright__ plugin_description = N_("Prelude Warning message") plugin_htdocs = (("warning", pkg_resources.resource_filename(__name__, 'htdocs')), ) _template = template.PrewikkaTemplate(__name__, "templates/warning.mak") @hookmanager.register("HOOK_LOAD_BODY_CONTENT") 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())])
class GenericListing(view.View): _template = template.PrewikkaTemplate(__name__, "templates/userlisting.mak") @hookmanager.register("HOOK_PLUGINS_LOAD") def _load(self): # Views are loaded before auth/session plugins if env.auth != env.session: # Do not declare routes with anonymous auth view.route("/settings/users", self.list_users, permissions=[N_("USER_MANAGEMENT")], menu=(N_("Access control"), N_("Users")), help="#users", parameters=GridParameters("users")) view.route("/settings/groups", self.list_groups, permissions=[N_("GROUP_MANAGEMENT")], menu=(N_("Access control"), N_("Groups")), help="#groups", parameters=GridParameters("users")) def _setup_dataset(self, type): dset = self._template.dataset() dset["type"] = type dset["all_permissions"] = sorted(usergroup.ACTIVE_PERMISSIONS) return dset def list_users(self): dset = self._setup_dataset("User") dset["backend_can_create"] = env.auth.can_create_user() dset["backend_can_delete"] = env.auth.can_delete_user() return dset.render() def list_groups(self): dset = self._setup_dataset("Group") dset["backend_can_create"] = env.auth.can_create_group() dset["backend_can_delete"] = env.auth.can_delete_group() return dset.render()
def listing(self): dataset = {} data = [] for fltr in self._db.get_filters(env.request.user): elem = { "id": fltr.name, "name": fltr.name, "description": fltr.description, "_link": url_for(".edit", name=fltr.name), "_title": _("Filter %s") % fltr.name } for typ in fltr.criteria: elem[typ] = True data.append(elem) dataset["data"] = data dataset["col_idents"], dataset["col_names"] = zip(*self._get_types()) return template.PrewikkaTemplate(__name__, "templates/filterlisting.mak").render(**dataset)
def riskoverview(self): # Don't show the risk overview if the user is not logged in if not env.request.user: return # We don't use groupby because the result won't be sorted then. objs = collections.OrderedDict((w, None) for w in self._widgets) for i in filter( None, hookmanager.trigger("HOOK_RISKOVERVIEW_DATA", _except=env.log.debug)): if i.name not in objs and self._widgets: continue elif objs.get(i.name) is None: objs[i.name] = i else: for j in i.data: objs[i.name].data.append(j) return view.ViewResponse( template.PrewikkaTemplate(__name__, "templates/table.mak").render( data=filter(None, objs.values())))
class BaseView(view._View): view_template = template.PrewikkaTemplate(__name__, 'templates/baseview.mak') 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"))
# GNU General Public License for more details. # # You should have received a copy of the GNU General Public License along # with this program; if not, write to the Free Software Foundation, Inc., # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. from __future__ import absolute_import, division, print_function, unicode_literals import calendar import datetime from dateutil.relativedelta import relativedelta from prewikka import hookmanager, localization, template, utils, view from prewikka.dataprovider import Criterion _MAINMENU_TEMPLATE = template.PrewikkaTemplate(__name__, "templates/mainmenu.mak") class MainMenuParameters(view.Parameters): allow_extra_parameters = False _INTERNAL_PARAMETERS = ["timeline_value", "timeline_unit", "timeline_end", "timeline_start", "timeline_absolute", "order_by", "timezone", "auto_apply_value"] def __init__(self, *args, **kwargs): # This will trigger register which in turn call a hook, do last view.Parameters.__init__(self, *args, **kwargs) def register(self): view.Parameters.register(self) self.optional("timeline_value", int, default=1, save=True, general=True)
class PrewikkaError(PrewikkaException): template = template.PrewikkaTemplate(__name__, 'templates/error.mak') name = N_("An unexpected condition happened") message = "" details = "" output = "" code = 500 log_priority = log.ERROR display_traceback = True errno = None def __init__(self, message, name=None, details=None, log_priority=None, log_user=None, template=None, code=None, output=None): if name is not None: self.name = name if message is not None: self.message = message if details is not None: self.details = details if template: self.template = template if code: self.code = code if log_priority: self.log_priority = log_priority if output: self.output = output self.traceback = self._get_traceback() self.log_user = log_user def _setup_template(self, template, ajax_error): dataset = template.dataset() for i in ("name", "message", "details", "code", "traceback", "errno", "output"): dataset[i] = getattr(self, i) dataset["is_ajax_error"] = ajax_error dataset["is_error_template"] = True return dataset def _html_respond(self): return env.viewmanager.get_baseview().respond( self._setup_template(self.template, False), self.code) def _get_traceback(self): if self.display_traceback and env.config.general.get_bool( "enable_error_traceback", True): return sys.exc_info() def respond(self): if self.message: env.log.log(self.log_priority, self) if not self.traceback: self.traceback = self._get_traceback() if not (env.request.web.is_stream or env.request.web.is_xhr): # This case should only occur in case of auth error (and viewmgr might not exist at this time) return self._html_respond() return response.PrewikkaResponse(self, code=self.code) @staticmethod def _format_error(message, details): if details: return "%s: %s" % (message, details) # message might be an exception class return text_type(message) def __str__(self): return self._format_error(self.message, self.details) def __json__(self): dset = self._setup_template(PrewikkaError.template, True) return {"content": dset.render(), "error": True}
def hosts(self): tmpl = template.PrewikkaTemplate(__name__, "templates/inventory.mak") inventory = self._db.get_hosts(env.request.parameters.get("search")) return tmpl.render(inventory=inventory, title=self._title)
def ajax_details(self): tmpl = template.PrewikkaTemplate(__name__, "templates/details.mak") return response.PrewikkaResponse( tmpl.dataset(fields_info=self.fields_info, fields_value=env.request.parameters))
def _get_dataset(self): return template.PrewikkaTemplate(__name__, "templates/forensic.mak").dataset()
def list(self): dataset = template.PrewikkaTemplate(__name__, "templates/crontab.mak").dataset() return dataset.render()