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 ajax_parameters_update(self, path):
viewobj, vkw = env.viewmanager.get_view_by_path(path)
viewobj.process_parameters()
if viewobj.view_menu:
view.GeneralParameters(viewobj, env.request.web.arguments)
return response.PrewikkaResponse(code=204)
def search(self):
# Used for autocomplete fields, no permissions required
limit = 10
objects = self._getObjects(search=env.request.parameters.get("term"))
return response.PrewikkaResponse([{
"value": obj.name,
"label": obj.name
} for obj in objects[:limit]])
def switch(self):
env.request.user.set_property("theme",
env.request.parameters.get("theme"))
env.request.user.sync_properties()
return response.PrewikkaResponse({
"type": "reload",
"target": "window"
})
def ajax_timeline(self):
query = self.query_parser(env.request.parameters.get("query"),
parent=self)
data = query.chronology(height=200)
return response.PrewikkaResponse(
resource.HTMLSource("""
%s
<script type="text/javascript">%s</script>
""" % (data["html"], data["script"] or "")))
def remove(self):
theme = env.request.parameters.get("theme")
self._check_theme(theme)
filename = os.path.join(
pkg_resources.resource_filename("prewikka", "htdocs"), "css",
"themes", "%s.css" % theme)
os.remove(filename)
return response.PrewikkaResponse({"type": "reload", "target": "view"})
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 _process_static(self, webreq):
pathkey = webreq.path_elements[0]
endpath = webreq.path[len(pathkey) + 2:]
mapping = env.htdocs_mapping.get(pathkey, None)
if not (mapping and endpath and "." in webreq.path_elements[-1]):
# There is no mapping, or no path beyond the mapped portion was provided.
# FIXME: .ext check is not clean: proper way to handle this would be to map statics
# files to a /static base directory
return
path = os.path.abspath(os.path.join(mapping, endpath))
if not path.startswith(mapping):
return response.PrewikkaResponse(code=403,
status_text="Request Forbidden")
try:
return response.PrewikkaFileResponse(path)
except OSError:
return response.PrewikkaResponse(code=404,
status_text="File not found")
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)
def mainmenu(self, datatype=None):
kwargs = {}
if datatype:
kwargs["criteria_type"] = datatype
return response.PrewikkaResponse({
"type":
"content",
"target":
"#main_menu_ng",
"content":
mainmenu.HTMLMainMenu(**kwargs)
})
def ajax_infos(self):
infos = collections.OrderedDict()
infos["general"] = utils.AttrObj(label=_("General"),
info=self._get_common_infos())
extra_infos = filter(
None,
hookmanager.trigger("HOOK_DATASEARCH_INFO",
env.request.parameters))
for category, data in itertools.chain(extra_infos,
self._get_extra_infos()):
infos[category] = data
return response.PrewikkaResponse({"infos": infos})
def delete(self):
criteria = dataprovider.Criterion()
for i in env.request.parameters.getlist("criteria",
type=utils.json.loads):
criteria |= i
if criteria:
env.dataprovider.delete(criteria)
return response.PrewikkaResponse({
"type": "reload",
"target": "#main",
"options": {
"current": False
}
})
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 enable(self):
upsrt = []
for catname, plugin in self._iter_plugin():
enabled = plugin.plugin_mandatory or plugin.full_module_name in env.request.parameters[
"enable_plugin"]
upsrt.append((plugin.full_module_name, enabled))
if upsrt:
env.db.upsert("Prewikka_Module_Registry", ["module", "enabled"],
upsrt,
pkey=["module"])
env.db.trigger_plugin_change()
return response.PrewikkaResponse({
"type": "reload",
"target": "window"
})
def save(self):
theme = env.request.parameters.get("theme")
self._check_theme(theme)
prewikka_path = pkg_resources.resource_filename("prewikka", "htdocs")
style = os.path.join(prewikka_path, "css", "style.less")
output = os.path.join(prewikka_path, "css", "themes", "%s.css" % theme)
tmp_file = tempfile.NamedTemporaryFile()
with open(tmp_file.name, "w") as f:
for category, variables in _LESS_VARIABLES:
for name, label in variables:
f.write("@%s: %s;" %
(name, env.request.parameters.get(name)))
os.system("lesscpy -I %s %s > %s" % (tmp_file.name, style, output))
return response.PrewikkaResponse({
"type": "reload",
"target": "window"
})
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 respond(self):
env.log.info("Loading view %s, endpoint %s" %
(self.__class__.__name__, self.view_endpoint))
resp = self._render()
if isinstance(resp, (template._Dataset, compat.STRING_TYPES)):
resp = ViewResponse(resp)
elif not (resp) or not issubclass(
resp.__class__,
response.PrewikkaResponse): # Any other type (eg: dict)
resp = response.PrewikkaResponse(resp)
if self.view_endpoint:
list(
hookmanager.trigger(
"HOOK_VIEW_%s_RESPONSE" % self.view_endpoint.upper(),
resp))
if resp.data:
resp.add_ext_content("_source", self.view_endpoint)
return resp
def history_get(self, form):
queries = history.get(env.request.user, form)
return response.PrewikkaResponse(queries)
def save(self, id=None):
crontab.update_from_parameters(id)
return response.PrewikkaResponse({"type": "reload", "target": "view"})
def enable(self):
crontab.update(env.request.parameters.getlist("id", type=int),
enabled=True)
return response.PrewikkaResponse({"type": "reload", "target": "view"})
def history_save(self, form):
if "query" in env.request.parameters:
history.save(env.request.user, form,
env.request.parameters["query"])
return response.PrewikkaResponse()
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 history_delete(self, form):
query = env.request.parameters[
"query"] if "query" in env.request.parameters else None
history.delete(env.request.user, form, query)
return response.PrewikkaResponse()
def respond(self, dataset=None, code=None):
return response.PrewikkaResponse(self._prepare(dataset), code=code)
def save(self, name):
user = usergroup.User(name)
modify_self = env.request.user == user
if not env.auth.has_user(user):
raise error.PrewikkaUserError(N_("Invalid user"),
N_("Specified user does not exist"),
log_priority=log.WARNING)
if name != env.request.user.name and not env.request.user.has(
"USER_MANAGEMENT"):
raise error.PrewikkaUserError(
N_("Permission Denied"),
N_("Cannot modify other users settings"),
log_priority=log.WARNING)
if not env.request.parameters[
"language"] in localization.get_languages():
raise error.PrewikkaUserError(
N_("Invalid Language"),
N_("Specified language does not exist"),
log_priority=log.WARNING)
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)
if "password_new" in env.request.parameters and env.request.parameters[
"password_new"] != env.request.parameters.get(
"password_new_confirmation"):
raise error.PrewikkaUserError(N_("Password error"),
N_("Password mismatch"))
reload_type = 0
for param, reload in (("fullname", "none"), ("email", "none"),
("timezone", "view"), ("theme", "window"),
("language", "window")):
value = env.request.parameters.get(param)
if value != user.get_property(param):
if value:
user.set_property(param, value)
else:
user.del_property(param)
if modify_self:
reload_type = max(reload_type, ReloadEnum[reload])
list(hookmanager.trigger("HOOK_USERMANAGEMENT_USER_MODIFY", user))
if env.request.user.has(
"USER_MANAGEMENT") and env.auth.can_manage_permissions():
permissions = self._make_permissions_from_parameters(
user.permissions)
if permissions != set(user.permissions):
old_perms = set(
env.auth.get_user_permissions(
user, ignore_group=True)).difference(
env.auth.get_user_permissions_from_groups(user))
user.permissions = permissions
self.log_property_list_change("permissions", user, old_perms,
permissions)
reload_type = max(
ReloadEnum["window"] if modify_self else
ReloadEnum[".commonlisting"], reload_type)
# Group memberships
if env.auth.can_manage_group_members():
groups = set(
usergroup.Group(i)
for i in env.request.parameters.getlist("member_object"))
if groups != set(env.auth.get_member_of(user)):
self.log_property_list_change("groups", user,
env.auth.get_member_of(user),
groups)
env.auth.set_member_of(user, groups)
reload_type = max(
ReloadEnum["window"] if modify_self else
ReloadEnum[".commonlisting"], reload_type)
if "password_new" in env.request.parameters:
if modify_self:
try:
env.auth.authenticate(
name,
env.request.parameters.get("password_current", ""))
except auth.AuthError:
raise error.PrewikkaUserError(
N_("Password error"), N_("Invalid password specified"))
env.auth.set_password(user, env.request.parameters["password_new"])
user.sync_properties()
if reload_type > ReloadEnum["none"]:
return response.PrewikkaResponse({
"type": "reload",
"target": reload_type.name
})
