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 save(self):
fname = env.request.parameters.get("filter_name")
if not fname:
raise error.PrewikkaUserError(N_("Could not save filter"), N_("No name for this filter was provided"))
criteria = dict(zip(
env.request.parameters.getlist("filter_types"),
(json.loads(c) for c in env.request.parameters.getlist("filter_criteria"))
))
fltr = self._db.get_filter(env.request.user, fname)
if fltr:
if env.request.parameters.get("filter_id") != fname:
raise error.PrewikkaUserError(N_("Could not save filter"), N_("The filter name is already used by another filter"))
# Do not erase filter components if the dataprovider failed to load
new_criteria = fltr.criteria
new_criteria.update(criteria)
criteria = new_criteria
criteria = dict((k, v) for k, v in criteria.items() if v is not None)
description = env.request.parameters.get("filter_description", "")
self._db.upsert_filter(env.request.user, Filter(fname, description, criteria))
return response.PrewikkaDirectResponse({"type": "ajax-reload"})
def __init__(self):
self._all_sections = set()
self._declared_sections = {}
self._loaded_sections = {}
self._sorted = False
self._default_view = None
self._default_section = None
self._default_tab = None
filename = env.config.interface.get("menu_order", "menu.yml")
if not os.path.isabs(filename):
filename = os.path.join(siteconfig.conf_dir, filename)
with open(filename, "r") as f:
self._menus = yaml.load(f)
if not self._menus:
raise error.PrewikkaUserError(N_("Menu error"), N_("Empty menu"))
default_menu = False
for menu in self._menus:
if "name" not in menu and "icon" not in menu:
raise error.PrewikkaUserError(
N_("Menu error"), N_("Menu without a name in %s",
filename))
if menu.get("default"):
if default_menu:
raise error.PrewikkaUserError(N_("Menu error"),
N_("Multiple default menus"))
default_menu = True
for category in menu.get("categories", []):
for section in category.get("sections", []):
if "name" not in section:
raise error.PrewikkaUserError(
N_("Menu error"),
N_("Section without a name in %s", filename))
if "default_tab" in section:
if self._default_section:
raise error.PrewikkaUserError(
N_("Menu error"), N_("Multiple default views"))
self._default_section, self._default_tab = (
section["name"], section["default_tab"])
self._declared_sections[section["name"]] = section.get(
"tabs", [])
if not default_menu:
self._menus[-1]["default"] = True
def edit(self, name=None, widget=True):
user = None
user_permissions = []
group_permissions = []
if not name:
target = url_for(".create")
else:
user = usergroup.User(name)
if not env.auth.has_user(user):
raise error.PrewikkaUserError(
_("Invalid User"),
N_("Requested user '%s' does not exist", user))
if user != env.request.user and not env.request.user.has(
"USER_MANAGEMENT"):
raise error.PrewikkaUserError(
_("Permission Denied"),
N_("Access denied to other users settings"),
log_priority=log.WARNING)
target = url_for(".save", name=name)
dset = self._setup_dataset(target, user)
if user:
dset["fullname"] = user.get_property("fullname")
dset["email"] = user.get_property("email")
dset["timezone"] = user.get_property(
"timezone", default=env.config.general.default_timezone)
dset["language"] = user.get_property(
"language", default=env.config.general.default_locale)
dset["user_theme"] = user.get_property(
"theme", default=env.config.general.default_theme)
user_permissions = env.auth.get_user_permissions(user,
ignore_group=True)
group_permissions = env.auth.get_user_permissions_from_groups(user)
dset["widget"] = widget
dset["ask_current_password"] = (user == env.request.user)
dset["permissions"] = []
for perm in sorted(usergroup.ACTIVE_PERMISSIONS):
dset["permissions"].append((perm, perm in user_permissions, perm
in group_permissions))
dset["extra_content"] = filter(
None,
hookmanager.trigger("HOOK_USERMANAGEMENT_EXTRA_CONTENT", user,
"user"))
return dset.render()
def __init__(self):
self._declared_sections = {}
self._loaded_sections = {}
self._default_view = None
filename = env.config.interface.get("menu_order", "menu.yml")
if not os.path.isabs(filename):
filename = os.path.join(env.config.basedir, filename)
try:
with open(filename, "r") as f:
self._menus = _SCHEMA(yaml.safe_load(f))
except (IOError, yaml.error.YAMLError, voluptuous.Invalid) as e:
raise error.PrewikkaUserError(
N_("Menu error"),
N_("The provided YAML menu is invalid"),
details=e)
if not self._menus:
raise error.PrewikkaUserError(N_("Menu error"), N_("Empty menu"))
default_menu = False
for menu in self._menus:
if "name" not in menu and "icon" not in menu:
raise error.PrewikkaUserError(
N_("Menu error"), N_("Menu without a name in %s",
filename))
if menu.get("default"):
if default_menu:
raise error.PrewikkaUserError(N_("Menu error"),
N_("Multiple default menus"))
default_menu = True
for category in menu["categories"]:
for section in category["sections"]:
if "default_tab" in section:
if self._default_view:
raise error.PrewikkaUserError(
N_("Menu error"), N_("Multiple default views"))
self._default_view = (section["name"],
section["default_tab"])
self._declared_sections[
section["name"]] = collections.OrderedDict(
(v, idx) for idx, v in enumerate(section["tabs"]))
if not default_menu:
self._menus[-1]["default"] = True
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 _load_widget(self):
widget = Widget(env.request.parameters["widget"])
categories = Widget.get_categories()
if categories:
if widget["category"] not in categories:
raise error.PrewikkaUserError(
N_("Invalid widget"),
N_("The widget category does not exist"))
data = categories[widget["category"]].prepare_render(widget)
if data:
return data
data = self._get_graph(widget)
if widget.get("period") and widget["category"] != "chronology":
dictperiod = dict(
('timeline_' + k, v) for k, v in widget["period"].items())
period = mainmenu.TimePeriod(dictperiod)
data["period_display"] = {
"start": localization.format_datetime(period.start),
"end": localization.format_datetime(period.end)
}
if widget.get("filter"):
data["filter"] = widget.get("filter")
return data
def _prepare_groupby_query(self, groupby, orderby):
self._paths["_aggregation"] = "count(1)"
groupby = set(groupby)
ogroup = list(groupby - set(_TEMPORAL_VALUES))
tgroup = list(groupby & set(_TEMPORAL_VALUES))
self.groupby = ogroup + tgroup
for field in ogroup:
if field not in self._parent.path_translate:
self._paths[field] = '%s%s/group_by' % (self.path_prefix,
field)
else:
for i in self._parent.path_translate[field][0]:
self._paths[field] = '%s/group_by' % i
self._handle_order(orderby)
if not tgroup:
return
if len(tgroup) > 1:
raise error.PrewikkaUserError(
N_("Time group error"),
N_("Only one time unit can be specified in a groupby query"))
self._time_group = tgroup[0]
self._date_selection_index = len(self._paths)
self._paths.update(
("_time_unit_%d" % i, path)
for i, path in enumerate(self._time_selection(self._time_group)))
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)
def _make_job(self, res):
id, name, userid, schedule, ext_type, ext_id, base, runcnt, enabled, error_s = res
func = self._plugin_callback.get(ext_type)
if not func:
err = error.PrewikkaUserError(
N_("Invalid job extension"),
N_("Scheduled job with invalid extension type '%s'", ext_type))
elif error_s:
err = utils.json.loads(error_s)
else:
err = None
if ext_id:
ext_id = int(ext_id)
if base:
base = env.db.parse_datetime(base)
user = None
if userid:
user = usergroup.User(userid=userid)
return CronJob(int(id),
name,
schedule,
func,
base,
int(runcnt),
ext_type=ext_type,
ext_id=ext_id,
user=user,
error=err,
enabled=bool(int(enabled)))
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 save(self, name=None):
new_name = env.request.parameters.get("filter_name")
category = env.request.parameters.get("filter_category")
description = env.request.parameters.get("filter_description")
if not new_name:
raise error.PrewikkaUserError(
N_("Could not save filter"),
N_("No name for this filter was provided"))
elif new_name.startswith("/"):
raise error.PrewikkaUserError(
N_("Could not save filter"),
N_("The filter name cannot start with a slash"))
criteria = dict(
zip(env.request.parameters.getlist("filter_types"),
(json.loads(c)
for c in env.request.parameters.getlist("filter_criteria"))))
filter_ = self._db.get_filter(env.request.user, name) if name else None
filter_id = filter_.id_ if filter_ else None
# Ensure the filter name is not already used by this user
if new_name != name and self._db.get_filter(env.request.user,
new_name):
raise error.PrewikkaUserError(
N_("Could not save filter"),
N_("The filter name is already used by another filter"))
# Do not erase filter components if the dataprovider failed to load
if filter_:
new_criteria = filter_.criteria
new_criteria.update(criteria)
criteria = new_criteria
criteria = dict((k, v) for k, v in criteria.items() if v is not None)
self._db.upsert_filter(
env.request.user,
Filter(filter_id, new_name, category, description, criteria))
return response.PrewikkaResponse({
"type": "reload",
"target": "#main_menu_ng",
"options": {
"filter": new_name
}
})
def _setup_renderer(self, type, renderer):
renderer = renderer or self.get_default_backend(type)
if renderer is None:
raise error.PrewikkaUserError(N_("Renderer error"),
N_("No backend supporting render type '%s'", type))
if renderer not in self._renderer:
raise error.PrewikkaUserError(N_("Renderer error"),
N_("No backend named '%s'", renderer))
if type not in self._renderer[renderer]:
raise error.PrewikkaUserError(N_("Renderer error"),
N_("Backend '%(backend)s' does not support render type '%(type)s'",
{'backend': renderer, 'type': type}))
return renderer
def delete(self):
if not env.request.user.has("GROUP_MANAGEMENT"):
raise error.PrewikkaUserError(
N_("Permission Denied"),
N_("Access denied to groups modification"),
log_priority=log.WARNING)
for obj in env.request.parameters.getlist("id"):
usergroup.Group(groupid=obj).delete()
def __init__(self):
self._account = env.config.twitter.get("account")
self._widget_id = env.config.twitter.get("widget-id")
if not self._account or not self._widget_id:
raise error.PrewikkaUserError(
"Missing configuration",
"Twitter plugin disabled: not configured")
pluginmanager.PluginBase.__init__(self)
def create(self):
group_name = env.request.parameters.get("name")
if not group_name:
raise error.PrewikkaUserError(N_("Could not create group"),
N_("No group name provided"))
if group_name.startswith("/"):
raise error.PrewikkaUserError(
N_("Could not create group"),
N_("Group name cannot start with a slash"))
group = usergroup.Group(group_name)
if env.auth.has_group(group):
raise error.PrewikkaUserError(
N_("Could not create group"),
N_("Group %s already exists", group_name))
group.create()
return self.save(group_name)
def to_datetime(date):
try:
return CONVERTERS[type(date)](date)
except KeyError:
raise error.PrewikkaUserError(
N_("Conversion error"),
N_("Value %(value)r cannot be converted to %(type)s", {
"value": date,
"type": "datetime"
}))
def extract_from_date(date, extract):
"""Extracts and returns the value of a specified datetime field
from a datetime.
"""
if not isinstance(date, datetime):
raise error.PrewikkaUserError(
N_("Invalid operation"),
N_("Extraction is supported only for date fields"))
attr = _EXTRACT_TO_DATETIME[extract]
return attr(date) if callable(attr) else getattr(date, attr)
def _cast(self, value):
type = self._get_current_path_type()
try:
return TYPES_FUNC_MAP[type](value)
except (KeyError, ValueError):
raise error.PrewikkaUserError(
N_("Conversion error"),
N_("Value %(value)r cannot be converted to %(type)s", {
"value": value,
"type": type
}))
def _check_version(self):
error_type = _("Version Requirement error")
if not prelude.checkVersion(siteconfig.libprelude_required_version):
raise error.PrewikkaUserError(
error_type,
N_(
"Prewikka %(vPre)s requires libprelude %(vLib)s or higher",
{
'vPre': version.__version__,
'vLib': siteconfig.libprelude_required_version
}))
elif not preludedb.checkVersion(
siteconfig.libpreludedb_required_version):
raise error.PrewikkaUserError(
error_type,
N_(
"Prewikka %(vPre)s requires libpreludedb %(vLib)s or higher",
{
'vPre': version.__version__,
'vLib': siteconfig.libpreludedb_required_version
}))
def _chart_prepare(self, query, options):
filter_name = options.get("filter")
if not filter_name:
return
c = self._filter_get_criteria_by_name(filter_name, query.datatype,
options.get("owner"))
if not c:
raise error.PrewikkaUserError(
N_("Filter error"),
N_("Filter '%s' does not exist", filter_name))
query.criteria &= c
def create(self):
login = env.request.parameters.get("name")
if not login:
raise error.PrewikkaUserError(N_("Could not create user"),
N_("Username required"))
if login.startswith("/"):
raise error.PrewikkaUserError(
N_("Could not create user"),
N_("Username cannot start with a slash"))
user = usergroup.User(login)
if env.auth.has_user(user):
raise error.PrewikkaUserError(N_("Could not create user"),
N_("User %s already exists", login))
user.create()
self.save(login)
return response.PrewikkaResponse({
"type": "reload",
"target": ".commonlisting"
})
def download(self, user=None, id=None, filename=None, inline=False):
if user and user != env.request.user.name:
raise error.PrewikkaUserError(
_("Permission Denied"),
message=_("Missing permission to access the specified file"),
code=403)
fd = open(utils.mkdownload.get_filename(id, filename, user), "rb")
filename = base64.urlsafe_b64decode(
filename.encode("utf8")).decode("utf8")
return response.PrewikkaDownloadResponse(fd,
filename=filename,
inline=inline)
def render(self, type, data, renderer=None, **kwargs):
if renderer is None:
renderer = self.get_default_backend(type)
if renderer is None:
raise error.PrewikkaUserError(N_("Renderer error"),
N_("No backend supporting render type '%s'", type))
if renderer not in self._renderer:
raise error.PrewikkaUserError(N_("Renderer error"),
N_("No backend named '%s'", renderer))
if type not in self._renderer[renderer]:
raise error.PrewikkaUserError(N_("Renderer error"),
N_("Backend '%(backend)s' does not support render type '%(type)s'",
{'backend': renderer, 'type': type}))
if not "names_and_colors" in kwargs:
kwargs["names_and_colors"] = COLOR_MAP
classname = kwargs["class"] = "-".join((renderer, type))
cssid = kwargs["cssid"] = "-".join((classname, text_type(uuid.uuid4())))
try:
data = self._renderer[renderer][type].render(data, **kwargs)
html = resource.HTMLSource("""<div id="%s" class="renderer-elem %s">%s</div>""" % (cssid, classname, data.get("html", "")))
return {"html": html, "script": resource.HTMLSource(data.get("script", "")) }
except RendererNoDataException as e:
html = resource.HTMLSource("""<div id="%s" class="renderer-elem renderer-elem-error %s">%s</div>""" % (cssid, classname, text_type(e)))
script = resource.HTMLSource("""
var size = prewikka_getRenderSize("#%s", %s);
$("#%s").width(size[0]).css("height", size[1] + 'px').css("line-height", size[1] + 'px');
""" % (cssid, json.dumps(kwargs), cssid))
return {"html": html, "script": script}
def update_from_parameters(self, id, delete_disabled=False, **kwargs):
schedule = env.request.parameters.get("quick-schedule")
if schedule != "disabled":
kwargs["schedule"] = schedule
try:
croniter.croniter(schedule)
except Exception:
raise error.PrewikkaUserError(
N_("Invalid schedule"),
N_("The specified job schedule is invalid"))
elif delete_disabled:
return crontab.delete(id=id, **kwargs)
crontab.update(id, enabled=int(schedule != "disabled"), **kwargs)
def _get_tabs(self, appli):
base_url = appli.get("base_url", "").rstrip('/')
tabs = self._make_list(appli.tab)
tab_urls = self._make_list(appli.tab_url)
if len(tab_urls) != len(tabs):
raise error.PrewikkaUserError(
N_("Could not load tabs"),
N_("A URL should be defined for each tab"))
for i, url in enumerate(tab_urls):
if not url.startswith('http://') and not url.startswith(
'https://'):
tab_urls[i] = "%s/%s" % (base_url, url)
return zip(tabs, tab_urls)
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)
def _load_auth_or_session(self,
typename,
plugins,
name,
config=config.SectionRoot()):
if name not in plugins:
raise error.PrewikkaUserError(
N_("Initialization error"),
N_(
"Cannot use %(type)s mode '%(name)s', please contact your local administrator.",
{
'type': typename,
'name': name
}))
obj = plugins[name](config)
setattr(env, typename, obj)
obj.init(config)
def _get_install_schema(self):
ret = self._list(to_version=self._reqversion,
branch=self._reqbranch,
type="install")
if not ret:
raise error.PrewikkaUserError(
N_("Database installation error"),
N_(
"No database installation script found for module %(module)s, version %(version)s",
{
'module':
self._full_module_name,
'version':
self._get_version_string(self._reqbranch,
self._reqversion)
}))
return ret[-1]
def _get_branch_update(self):
prev = self._resolve_branch_switch(self._from_branch,
self._from_version)
if not prev:
raise error.PrewikkaUserError(
N_("Database migration error"),
N_(
"No database branch migration script found for module %(module)s, branch transition %(current)s -> %(required)s",
{
'module':
self._full_module_name,
'current':
self._get_version_string(self._from_branch,
self._from_version),
'required':
self._get_version_string(self._reqbranch,
"<=" + self._reqversion)
}))
return prev
