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