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()
