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