def execute_delete(self): # """ Action for "delete" :since: v0.1.00 """ form_field_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_field_id", "")).strip() form_field_entry_position = InputFilter.filter_int(self.request.get_dsd("oform_field_entry_position", -1)) if (form_field_entry_position > -1): # form_store = self._get_form_store() form_store_dict = form_store.get_value_dict() form_store_field_id = "form_api_dynamic_{0}".format(form_field_id) entry_list = form_store_dict.get(form_store_field_id, [ ]) if (len(entry_list) > form_field_entry_position): del(entry_list[form_field_entry_position]) form_store_dict[form_store_field_id] = entry_list form_store.set_value_dict(form_store_dict) # redirect_request = PredefinedHttpRequest() redirect_request.set_module(self.request.get_module()) redirect_request.set_service(self.request.get_service()) redirect_request.set_action("get") redirect_request.set_dsd_dict(self.request.get_dsd_dict()) self.request.redirect(redirect_request)
def parse_dsd(dsd): """ DSD stands for dynamic service data and should be used for transfering IDs for news, topics, ... Take care for injection attacks! :param dsd: DSD string for parsing :return: (dict) Parsed DSD :since: v1.0.0 """ dsd = InputFilter.filter_control_chars(dsd) if ("+" not in dsd and VirtualRoute.RE_PLUS_ENCODED_CHAR.search(dsd) is not None): dsd = Uri.decode_query_value(dsd) elif (" " in dsd): dsd = Uri.encode_query_value(dsd) dsd = VirtualRoute.RE_DSD_PLUS_SPAM_CHAR.sub("++", dsd) dsd_list = dsd.split("++") _return = { } for dsd in dsd_list: dsd_element = dsd.strip().split("+", 1) if (len(dsd_element) > 1): _return[dsd_element[0]] = InputFilter.filter_control_chars(Uri.decode_query_value(dsd_element[1])) elif (len(dsd_element[0]) > 0): _return[dsd_element[0]] = "" # return _return
def execute_new(self, is_save_mode = False): # """ Action for "new" :since: v0.1.00 """ # pylint: disable=star-args tid = InputFilter.filter_file_path(self.request.get_dsd("dtid", "")) oid = InputFilter.filter_file_path(self.request.get_dsd("doid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() if (source_iline == ""): # source_iline = ("m=discuss;dsd=dpid+{0}".format(Link.encode_query_value(oid)) if (tid == "") else "m=discuss;dsd=dtid+{0}".format(Link.encode_query_value(tid)) ) # if (target_iline == ""): target_iline = "m=discuss;dsd=dpid+__id_d__" if (tid != ""): oid = tid self._execute_new("new", oid, source_iline = source_iline, target_iline = target_iline, is_save_mode = is_save_mode )
def execute_new(self, is_save_mode = False): # """ Action for "new" :since: v0.1.00 """ form_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_id", "")).strip() form_field_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_field_id", "")).strip() L10n.init("pas_http_core_form") form = FormProcessor(form_id) form.set_form_render_id(Binary.str(hexlify(urandom(16)))) if (is_save_mode): form.set_input_available() self._apply_new_form(form) if (is_save_mode and form.check()): # entry_data = self._save_new_form(form) form_store = form.get_form_store() form_store_dict = form_store.get_value_dict() form_store_field_id = "form_api_dynamic_{0}".format(form_field_id) entry_list = form_store_dict.get(form_store_field_id, [ ]) entry_list.append(entry_data) form_store_dict[form_store_field_id] = entry_list form_store.set_value_dict(form_store_dict) self._set_destroy_dom_result() # else: # content = { "title": self._get_form_action_new_title(), "on_closed_query": Link().build_url(Link.TYPE_QUERY_STRING, { "__request__": True, "a": "get" }) } content['form'] = { "object": form, "url_parameters": { "__request__": True, "a": "new-save" }, "button_title": "core_continue" } method = (self._set_replace_dom_oset_result if (is_save_mode) else self._set_append_overlay_dom_oset_result ) method("dynamic_form.overlay", content)
def execute_delete(self): """ Action for "delete" :since: v0.2.00 """ cid = InputFilter.filter_file_path(self.request.get_dsd("mcid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() if (source_iline == ""): source_iline = "m=mp;a=list_root_containers" if (target_iline == ""): target_iline = source_iline L10n.init("mp_core") session = (self.request.get_session() if (self.request.is_supported("session")) else None) user_profile = (None if (session is None) else session.get_user_profile()) if (user_profile is None or (not user_profile.is_type("ad")) ): raise TranslatableError("core_access_denied", 403) try: mp_entry = MpEntry.load_id(cid) except NothingMatchedException as handled_exception: raise TranslatableError("mp_core_cid_invalid", 404, _exception = handled_exception) if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) if (not DatabaseTasks.is_available()): raise TranslatableException("pas_core_tasks_daemon_not_available") mp_entry.delete() database_tasks = DatabaseTasks.get_instance() database_tasks.add("dNG.pas.upnp.Resource.onDeleted.{0}".format(cid), "dNG.pas.upnp.Resource.onDeleted", 1, container_id = cid) database_tasks.add("dNG.pas.upnp.Resource.onRootContainerDeleted.{0}".format(cid), "dNG.pas.upnp.Resource.onRootContainerDeleted", 1, container_id = cid) target_iline = re.sub("\\_\\w+\\_\\_", "", target_iline) NotificationStore.get_instance().add_completed_info(L10n.get("mp_core_done_root_container_delete")) Link.clear_store("servicemenu") redirect_request = PredefinedHttpRequest() redirect_request.set_iline(target_iline) self.request.redirect(redirect_request)
def execute_logout(self): """ Action for "logout" :since: v0.2.00 """ source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() if (target_iline == ""): if (Settings.is_defined("pas_http_user_logout_default_target_lang_{0}".format(self.request.get_lang()))): target_iline = Settings.get("pas_http_user_logout_default_target_lang_{0}".format(self.request.get_lang())) elif (Settings.is_defined("pas_http_user_logout_default_target")): target_iline = Settings.get("pas_http_user_logout_default_target") else: target_iline = source_iline # L10n.init("pas_http_user") if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) if (not self.request.is_supported("session")): raise TranslatableError("core_unknown_error", 500) session = Session.load(session_create = False) if (session is not None): session.delete() self.request.set_session(None) # Link.clear_store("servicemenu") target_iline = re.sub("\\_\\_\\w+\\_\\_", "", target_iline) redirect_request = PredefinedHttpRequest() redirect_request.set_module("output") redirect_request.set_service("http") redirect_request.set_action("done") redirect_request.set_parameter_chained("title", L10n.get("pas_http_user_logout")) redirect_request.set_parameter_chained("message", L10n.get("pas_http_user_done_logout")) redirect_request.set_parameter_chained("target_iline", target_iline) self.request.redirect(redirect_request)
def execute(self): # """ Executes the processor. :since: v0.1.00 """ if (self.form is None or (not self.validate_settings(self.settings))): raise ValueException("Processor is not configured") lang = (self.settings['email_lang'] if ("email_lang" in self.settings) else L10n.get_instance().get_lang() ) sender = (InputFilter.filter_control_chars(self.form.get_input(self.settings['email_sender_field_name'])) if ("email_sender_field_name" in self.settings) else None ) subject = (InputFilter.filter_control_chars(self.form.get_input(self.settings['email_subject_field_name'])) if ("email_subject_field_name" in self.settings) else self.settings['email_subject_title'] ) if (subject is None or len(subject.strip()) < 1): raise ValueException("Given e-mail subject is invalid") content_list = [ ] titles = self.settings.get("form_field_titles", { }) for field_name in self.settings['email_content_field_names']: # value = InputFilter.filter_control_chars(self.form.get_input(field_name)) content_list.append("{0}:\n{1}".format((titles[field_name] if (field_name in titles) else field_name), value ) ) # content = "\n\n".join(content_list) DatabaseTasks.get_instance().add("dNG.pas.http.Form.sendEMail.{0}".format(Binary.str(hexlify(urandom(16)))), "dNG.pas.http.Form.sendEMail", 1, lang = lang, sender = sender, subject = subject, content = content )
def execute_register(self, is_save_mode = False): """ Action for "register" :since: v0.2.00 """ source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() self._execute_register(source_iline = source_iline, target_iline = target_iline, is_save_mode = is_save_mode )
def get_view(self): """ Action for "view" :since: v1.0.0 """ cid = InputFilter.filter_file_path(self.request.get_parameter("cid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_parameter("source", "")).strip() L10n.init("pas_http_core_contentfile") Settings.read_file("{0}/settings/pas_http_contentfiles.json".format(Settings.get("path_data"))) contentfiles = Settings.get("pas_http_contentfiles_list", { }) if (type(contentfiles) is not dict): raise TranslatableError("pas_http_core_contentfile_cid_invalid", 404) if (source_iline != ""): if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.css") Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) # if (cid not in contentfiles or "title" not in contentfiles[cid] or "filepath" not in contentfiles[cid] ): raise TranslatableError("pas_http_core_contentfile_cid_invalid", 404) file_content = FileContent.read(contentfiles[cid]['filepath']) if (file_content is None): raise TranslatableError("pas_http_core_contentfile_cid_invalid", 404) if (path.splitext(contentfiles[cid]['filepath'])[1].lower() == ".ftg"): file_content = FormTags.render(file_content) content = { "title": contentfiles[cid]['title'], "content": file_content } self.response.init() self.response.page_title = contentfiles[cid]['title'] self.response.add_oset_content("core.simple_content", content)
def execute_subscribe(self): # """ Action for "subscribe" :since: v0.1.00 """ _id = InputFilter.filter_file_path(self.request.get_dsd("oid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() L10n.init("pas_http_datalinker") L10n.init("pas_http_subscription") if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") if (len(source_iline) > 0): # Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) # session = (self.request.get_session() if (self.request.is_supported("session")) else None) subscription_handler = self._get_subscription_handler(_id) if (subscription_handler is None): NotificationStore.get_instance().add_error(L10n.get("errors_pas_http_subscription_not_subscribable")) elif (not subscription_handler.is_subscribable_for_session_user(session)): NotificationStore.get_instance().add_error(L10n.get("errors_pas_http_subscription_not_subscribable")) else: # subscription_handler.set_session(session) if (not subscription_handler.is_subscribed()): subscription_handler.subscribe() NotificationStore.get_instance().add_completed_info(L10n.get("pas_http_subscription_done_subscribe")) # source_iline = re.sub("\\_\\_\\w+\\_\\_", "", source_iline) Link.clear_store("servicemenu") redirect_request = PredefinedHttpRequest() redirect_request.set_iline(source_iline) self.request.redirect(redirect_request)
def theme(self, theme): """ Sets the theme to use. :param theme: Output theme :since: v1.0.0 """ theme = Binary.str(theme) """ Set theme or reset to None to use the default one configured """ if (theme is None): self._theme = None else: theme_path = InputFilter.filter_file_path(theme).replace(".", path.sep) file_path_name = path.join(self.path, theme_path, "site.tsc") if (os.access(file_path_name, os.R_OK)): self._theme = theme else: self._theme = None # """ Read corresponding theme configuration """ if (self._theme is None): file_path_name = path.join(self.path, self.theme.replace(".", path.sep), "site.tsc") file_path_name = file_path_name[:-3] + "json" Settings.read_file(file_path_name)
def validate_settings(self, data): # """ Called to validate the given settings. :param data: Setting dict to be verified :since: v0.1.00 """ _return = False if (isinstance(data, dict) and DatabaseTasks.is_available() and "recipient" in data and "email_content_field_names" in data and ("email_subject_field_name" in data or "email_subject_title" in data) ): # _return = True recipient = InputFilter.filter_email_address(data['recipient']) if (recipient == ""): _return = False if (type(data['email_content_field_names']) is not list): _return = False if ("email_subject_title" in data and len(data['email_subject_title']) < 1): _return = False # return _return # # ##j## EOF
def execute_get(self): # """ Action for "get" :since: v0.1.00 """ if (not self.response.is_supported("dict_result_renderer")): raise IOException("Unsupported response object for action") form_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_id")) form_field_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_field_id")) try: form_store = Processor.load_form_store_id(form_id) except NothingMatchedException as handled_exception: raise TranslatableException("core_access_denied", 403, _exception = handled_exception) self._handle_get_choices(form_store, form_field_id)
def _set_append_dom_result(self, dom_value, **kwargs): """ Returns the DOM value given and activates the client API "append_dom". "append_dom_id" is used in case the client target DOM ID does not correspond to the one calling the server API. :param dom_value: DOM value to response :since: v0.2.00 """ api_call = "append_dom" dom_id = self.dom_id if (dom_id is None): dom_id = InputFilter.filter_file_path(self.request.get_dsd("ddom_id", "")) elif (self.request.get_dsd("ddom_id", "") != dom_id): api_call = "append_dom_id" result = kwargs result.update({ "api_call": api_call, "dom_id": dom_id, "dom_value": dom_value }) self.response.set_result(result)
def get_app_configuration(self, api_version, template_type, client_details): """ Returns ApiEndpoint settings based on the given API version. :param api_version: API version requested :param template_type: Template type requested by the client :param client_details: JSON encoded client details :return: (dict) ApiEndpoint settings :since: v0.2.00 """ if (template_type == ""): template_type = "ten_foot_web" template_type = "leanback_{0}".format(InputFilter.filter_control_chars(template_type).strip()) session = Session.load() if (session.get("mp.leanback.user_agent") != self.client_user_agent): session.set("mp.leanback.access_granted", True) session.set("mp.leanback.user_agent", self.client_user_agent) session.set("mp.leanback.template_type", template_type) session.save() # url_parameters = { "m": "mp", "s": "leanback", "a": "dashboard", "uuid": session.get_uuid() } url = Link.get_preferred("upnp").build_url(Link.TYPE_ABSOLUTE_URL, url_parameters) return JsonResource().data_to_json({ "url": url })
def get_user_agent_settings(user_agent): """ Returns the user agent specific client settings dictionary. :param user_agent: User agent :return: (dict) User agent specific client settings; None on error :since: v0.2.00 """ _return = { } settings = None user_agent = Binary.str(user_agent) if (type(user_agent) is str): settings = Hook.call("dNG.pas.upnp.Client.getUserAgentSettings", user_agent = user_agent) if (not isinstance(settings, dict)): identifier = ClientSettings.get_user_agent_identifiers(user_agent) settings_file_name = "{0}.json".format(identifier) settings = JsonFileContent.read(path.join(Settings.get("path_data"), "upnp", "user_agents", settings_file_name ) ) if (settings is None): log_line = "pas.upnp.ClientSettings reporting: No client settings found for user agent '{0}' with identifier '{1}'" if (Settings.get("pas_upnp_log_missing_user_agent", False)): LogLine.warning(log_line, user_agent, identifier, context = "pas_upnp") else: LogLine.debug(log_line, user_agent, identifier, context = "pas_upnp") # # # if (settings is not None): if ("client_file" in settings): base_settings = JsonFileContent.read(path.join(Settings.get("path_data"), "upnp", "user_agents", InputFilter.filter_file_path(settings['client_file']) ) ) if (type(base_settings) is dict): _return.update(base_settings) del(settings['client_file']) # _return.update(settings) # return _return
def _get_form_store(self): # """ Returns the form store in use for this dynamic field. :return: (object) The form store in use for this dynamic field :since: v0.1.00 """ form_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_id")) return FormProcessor.load_form_store_id(form_id)
def _get_form_field_list(self): # """ Returns the content of the form store for this dynamic field. :return: (dict) Content of the form store for this dynamic field :since: v0.1.00 """ form_field_id = InputFilter.filter_control_chars(self.request.get_dsd("oform_field_id")) form_value_dict = self._get_form_store().get_value_dict() return form_value_dict.get("form_api_dynamic_{0}".format(form_field_id), [ ])
def cookies(self): """ Returns request cookies. :return: (dict) Request cookie name as key and value :since: v1.0.0 """ _return = { } cookies = Header.get_field_list_dict(InputFilter.filter_control_chars(self.get_header("Cookie")), ";", "=") for cookie in cookies: _return[cookie['key']] = cookie['value'] return _return
def execute_reply(self, is_save_mode = False): # """ Action for "reply" :since: v0.1.00 """ # pylint: disable=star-args pid = InputFilter.filter_file_path(self.request.get_dsd("dpid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() if (source_iline == ""): source_iline = "m=discuss;dsd=dpid+{0}".format(Link.encode_query_value(pid)) if (target_iline == ""): target_iline = "m=discuss;dsd=dpid+__id_d__" self._execute_new("reply", pid = pid, source_iline = source_iline, target_iline = target_iline, is_save_mode = is_save_mode )
def get_sort_capabilities(self): """ Returns the UPnP sort capabilities. :return: (str) UPnP sort capabilities :since: v0.2.00 """ didl_fields = Hook.call("dNG.pas.upnp.Resource.getSortableDidlFields", client_user_agent = self.client_user_agent) if (type(didl_fields) != list or len(didl_fields) < 1): didl_fields = None if (didl_fields is None): _return = "" else: _return = ",".join(InputFilter.filter_unique_list(didl_fields)) return _return
def _read_parameters(self): """ Reads and returns the request parameters from the incoming request. :return: (dict) Request parameters :since: v1.0.0 """ _return = AbstractHttpRequest._read_parameters(self) request_body = self.prepare_body_instance(content_type_expected = "application/x-www-form-urlencoded") if (request_body is None): request_body = self.prepare_body_instance(content_type_expected = "multipart/form-data") if (isinstance(request_body, Mapping)): for key in request_body: _return[InputFilter.filter_control_chars(key)] = request_body[key] # return _return
def new_from_uploaded_file(uploaded_file, timeout = None): """ Creates a new Entry instance for an uploaded file backed by an StoredFile instance. :param uploaded_file: Uploaded file instance :param timeout: Timeout for copying data :return: (object) Entry instance on success :since: v0.1.00 """ _return = Entry.new_stored_file() entry_data = { "size": uploaded_file.get_size() } file_name = InputFilter.filter_file_path(uploaded_file.get_client_file_name()) if (file_name != ""): entry_data['title'] = file_name file_content_type = uploaded_file.get_client_content_type() mimetype_definition = MimeType.get_instance().get(mimetype = file_content_type) if (mimetype_definition is None and file_name != ""): file_name_ext = path.splitext(file_name)[1] mimetype_definition = MimeType.get_instance().get(file_name_ext[1:]) # if (mimetype_definition is not None): entry_data['mimeclass'] = mimetype_definition['class'] entry_data['mimetype'] = mimetype_definition['type'] elif (file_content_type is not None and "/" in file_content_type): file_content_type_data = file_content_type.split("/", 1) entry_data['mimeclass'] = file_content_type_data[0] entry_data['mimetype'] = file_content_type_data[1] # _return.set_data_attributes(**entry_data) uploaded_file.copy_data(_return, timeout) return _return
def execute_api_get_configuration(self): """ Action for "api_get_configuration" :since: v0.2.00 """ user_agent = self.request.get_header("User-Agent") template_type = (self.request.get_parameter_chained("attype", "ten_foot_web") if (self.request.is_supported("parameters_chained")) else self.request.get_parameter("attype", "ten_foot_web") ) template_type = "leanback_{0}".format(InputFilter.filter_control_chars(template_type).strip()) self.response.init(True) self.response.set_header("Access-Control-Allow-Origin", "*") if (not self.response.is_supported("dict_result_renderer")): raise TranslatableError("core_access_denied", 403) self._ensure_access_granted() session = Session.load() if (session.get("mp.leanback.user_agent") != user_agent): session.set("mp.leanback.access_granted", True) session.set("mp.leanback.user_agent", user_agent) session.set("mp.leanback.template_type", template_type) session.set_cookie(Settings.get("pas_http_site_cookies_supported", True)) session.save() self.request.set_session(session) # url_parameters = { "m": "mp", "s": "leanback", "a": "dashboard", "uuid": session.get_uuid() } self.response.set_result({ "url": Link.get_preferred("upnp").build_url(Link.TYPE_ABSOLUTE_URL, url_parameters) })
def _check_username_not_registered(self, field, validator_context): """ Form validator that checks if the user name is not already registered. :param field: Form field :param validator_context: Form validator context :return: (str) Error message; None on success :since: v0.2.00 """ _return = None user_profile_class = NamedLoader.get_class("dNG.data.user.Profile") if (user_profile_class is None): _return = L10n.get("pas_http_core_form_error_internal_error") else: try: user_profile_class.load_username(InputFilter.filter_control_chars(field.get_value()), True) _return = L10n.get("pas_http_user_form_error_username_exists") except NothingMatchedException: pass # return _return
def execute_error(self): """ Action for "error" :since: v1.0.0 """ code = InputFilter.filter_int(self.request.get_parameter("code", "500")) if (L10n.is_defined("errors_pas_http_core_{0:d}".format(code))): if (self.response.is_supported("headers")): self.response.set_header("HTTP", ("HTTP/2.0 {0:d} {1}".format(code, self.error_messages[code]) if (code in self.error_messages) else "HTTP/2.0 500 Internal Server Error" ), True ) # self.response.handle_error("pas_http_core_{0:d}".format(code)) else: if (self.response.is_supported("headers")): self.response.set_header("HTTP", "HTTP/2.0 500 Internal Server Error", True) self.response.handle_critical_error("core_unknown_error")
def execute_list_root_containers(self): """ Action for "list_root_containers" :since: v0.2.00 """ page = InputFilter.filter_int(self.request.get_dsd("mpage", 1)) L10n.init("mp_core") session = (self.request.get_session() if (self.request.is_supported("session")) else None) user_profile = (None if (session is None) else session.get_user_profile()) if (user_profile is None or (not user_profile.is_type("ad")) ): raise TranslatableError("core_access_denied", 403) if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") Link.set_store("servicemenu", (Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED), L10n.get("mp_core_root_container_new"), { "m": "mp", "s": "root_container", "a": "new" }, icon = "mini-default-option", priority = 3 ) content = { "title": L10n.get("mp_core_root_container_list"), "entries": MpEntry.get_root_containers_count(), "page": page } self.response.init() self.response.set_title(content['title']) self.response.add_oset_content("mp.container", content)
def execute_new(self, is_save_mode = False): """ Action for "new" :since: v0.2.00 """ # pylint: disable=star-args cid = InputFilter.filter_file_path(self.request.get_dsd("ccid", "")) oid = InputFilter.filter_file_path(self.request.get_dsd("coid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() source = source_iline if (source_iline == ""): source_iline = ("m=contentor;dsd=cdid+{0}".format(Link.encode_query_value(oid)) if (cid == "") else "m=contentor;dsd=ccid+{0}".format(Link.encode_query_value(cid)) ) # target = target_iline if (target_iline == ""): target_iline = "m=contentor;dsd=cdid+__id_d__" L10n.init("pas_http_contentor") L10n.init("pas_http_datalinker") if (cid != ""): oid = cid try: category = Category.load_id(oid) except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_datalinker_oid_invalid", 404, _exception = handled_exception) session = (self.request.get_session() if (self.request.is_supported("session")) else None) if (isinstance(category, OwnableInstance) and (not category.is_writable_for_session_user(session))): raise TranslatableError("core_access_denied", 403) if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) if (not DatabaseTasks.is_available()): raise TranslatableException("pas_core_tasks_daemon_not_available") form_id = InputFilter.filter_control_chars(self.request.get_parameter("form_id")) form = FormProcessor(form_id) form.set_context({ "category": category, "form": "new" }) if (is_save_mode): form.set_input_available() self._apply_form(form) if (is_save_mode and form.check()): document = _Document() did_d = None document_title = InputFilter.filter_control_chars(form.get_value("ctitle")) document_tag = InputFilter.filter_control_chars(form.get_value("ctag")) document_description = InputFilter.filter_control_chars(form.get_value("cdescription")) document_content = InputFilter.filter_control_chars(form.get_value("ccontent")) document_data = { "title": document_title, "tag": document_tag, "author_ip": self.request.get_client_host(), "content": FormTags.encode(document_content), "description": FormTags.encode(document_description) } user_profile = (None if (session is None) else session.get_user_profile()) if (user_profile is not None): document_data['author_id'] = user_profile.get_id() with TransactionContext(): document.set_data_attributes(**document_data) document.set_permission_session(session) document.set_manageable_if_logged_in() if (isinstance(category, DataLinker)): category.add_entry(document) document.save() # did_d = document.get_id() DatabaseTasks.get_instance().add("dNG.pas.contentor.Document.onAdded.{0}".format(did_d), "dNG.pas.contentor.Document.onAdded", 1, category_id = oid, document_id = did_d ) target_iline = target_iline.replace("__id_d__", "{0}".format(did_d)) target_iline = re.sub("\\_\\_\\w+\\_\\_", "", target_iline) NotificationStore.get_instance().add_completed_info(L10n.get("pas_http_contentor_done_document_new")) Link.clear_store("servicemenu") redirect_request = PredefinedHttpRequest() redirect_request.set_iline(target_iline) self.request.redirect(redirect_request) else: content = { "title": L10n.get("pas_http_contentor_document_new") } content['form'] = { "object": form, "url_parameters": { "__request__": True, "a": "new-save", "dsd": { "source": source, "target": target } }, "button_title": "pas_core_save" } self.response.init() self.response.set_title(content['title']) self.response.add_oset_content("core.form", content)
def execute_edit(self, is_save_mode = False): """ Action for "edit" :since: v0.2.00 """ did = InputFilter.filter_file_path(self.request.get_dsd("cdid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() source = source_iline if (source_iline == ""): source_iline = "m=contentor;dsd=cdid+{0}".format(Link.encode_query_value(did)) target = target_iline if (target_iline == ""): target_iline = source_iline L10n.init("pas_http_contentor") try: document = _Document.load_id(did) except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_contentor_did_invalid", 404, _exception = handled_exception) session = (self.request.get_session() if (self.request.is_supported("session")) else None) if (session is not None): document.set_permission_session(session) if (not document.is_manageable()): raise TranslatableError("core_access_denied", 403) document_parent = document.load_parent() if (isinstance(document_parent, OwnableInstance) and (not document_parent.is_readable_for_session_user(session))): raise TranslatableError("core_access_denied", 403) if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) if (not DatabaseTasks.is_available()): raise TranslatableException("pas_core_tasks_daemon_not_available") document_data = document.get_data_attributes("tag") form_id = InputFilter.filter_control_chars(self.request.get_parameter("form_id")) form = FormProcessor(form_id) form.set_context({ "category": document_parent, "form": "edit", "current_tag": document_data['tag'] }) if (is_save_mode): form.set_input_available() self._apply_form(form, document) if (is_save_mode and form.check()): document_title = InputFilter.filter_control_chars(form.get_value("ctitle")) document_tag = InputFilter.filter_control_chars(form.get_value("ctag")) document_description = InputFilter.filter_control_chars(form.get_value("cdescription")) document_content = InputFilter.filter_control_chars(form.get_value("ccontent")) document.set_data_attributes(time_sortable = time(), title = document_title, tag = document_tag, content = FormTags.encode(document_content), description = FormTags.encode(document_description) ) document.save() cid = (did if (document.is_main_entry()) else document_parent.get_id()) DatabaseTasks.get_instance().add("dNG.pas.contentor.Document.onUpdated.{0}".format(did), "dNG.pas.contentor.Document.onUpdated", 1, category_id = cid, document_id = did ) target_iline = target_iline.replace("__id_d__", "{0}".format(did)) target_iline = re.sub("\\_\\w+\\_\\_", "", target_iline) NotificationStore.get_instance().add_completed_info(L10n.get("pas_http_contentor_done_document_edit")) Link.clear_store("servicemenu") redirect_request = PredefinedHttpRequest() redirect_request.set_iline(target_iline) self.request.redirect(redirect_request) else: content = { "title": L10n.get("pas_http_contentor_document_edit") } content['form'] = { "object": form, "url_parameters": { "__request__": True, "a": "edit-save", "dsd": { "source": source, "target": target } }, "button_title": "pas_http_core_edit" } self.response.init() self.response.set_title(content['title']) self.response.add_oset_content("core.form", content)
def execute_new(self, is_save_mode = False): # """ Action for "new" :since: v0.1.00 """ # pylint: disable=star-args lid = InputFilter.filter_file_path(self.request.get_dsd("dlid", "")) oid = InputFilter.filter_file_path(self.request.get_dsd("doid", "")) source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip() target_iline = InputFilter.filter_control_chars(self.request.get_dsd("target", "")).strip() source = source_iline if (source_iline == ""): # source_iline = ("m=discuss;dsd=dtid+{0}".format(Link.encode_query_value(oid)) if (lid == "") else "m=discuss;dsd=dlid+{0}".format(Link.encode_query_value(lid)) ) # target = target_iline if (target_iline == ""): target_iline = "m=discuss;dsd=dtid+__id_d__" L10n.init("pas_http_datalinker") L10n.init("pas_http_discuss") if (lid != ""): oid = lid try: _list = List.load_id(oid) except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_datalinker_oid_invalid", 404, _exception = handled_exception) is_manageable = False session = (self.request.get_session() if (self.request.is_supported("session")) else None) if (isinstance(_list, OwnableInstance)): # if (not _list.is_writable_for_session_user(session)): raise TranslatableError("core_access_denied", 403) is_manageable = _list.is_manageable_for_session_user(session) # elif (session is not None): # user_profile = session.get_user_profile() if (user_profile is not None): is_manageable = user_profile.is_type("ad") # if (self.response.is_supported("html_css_files")): self.response.add_theme_css_file("mini_default_sprite.min.css") Link.set_store("servicemenu", Link.TYPE_RELATIVE_URL, L10n.get("core_back"), { "__query__": re.sub("\\_\\_\\w+\\_\\_", "", source_iline) }, icon = "mini-default-back", priority = 7 ) if (not DatabaseTasks.is_available()): raise TranslatableException("pas_core_tasks_daemon_not_available") form_id = InputFilter.filter_control_chars(self.request.get_parameter("form_id")) form = FormProcessor(form_id) form.set_context({ "form": "new", "list": _list }) if (is_save_mode): form.set_input_available() field = TextField("dtitle") field.set_title(L10n.get("pas_http_discuss_topic_title")) field.set_required() field.set_size(TextField.SIZE_LARGE) field.set_limits(int(Settings.get("pas_http_discuss_topic_title_min", 10))) form.add(field) if (is_manageable): # field = TextField("dtag") field.set_title(L10n.get("pas_http_discuss_topic_tag")) field.set_size(TextField.SIZE_SMALL) field.set_limits(_max = 255) field.set_validators([ self._check_tag_unique ]) form.add(field) # field = TextareaField("ddescription") field.set_title(L10n.get("pas_http_discuss_topic_description")) field.set_size(TextField.SIZE_SMALL) field.set_limits(_max = 255) form.add(field) field = FormTagsTextareaField("dpost") field.set_title(L10n.get("pas_http_discuss_post_content")) field.set_required() field.set_size(FormTagsTextareaField.SIZE_LARGE) field.set_limits(int(Settings.get("pas_http_discuss_post_content_min", 6))) form.add(field) if (is_save_mode and form.check()): # is_list = isinstance(_list, List) is_datalinker_entry = (True if (is_list) else isinstance(_list, List)) topic = _Topic() tid_d = None post = Post() topic_timestamp = time() topic_title = InputFilter.filter_control_chars(form.get_value("dtitle")) topic_description = InputFilter.filter_control_chars(form.get_value("ddescription")) topic_tag = (InputFilter.filter_control_chars(form.get_value("dtag")) if (is_manageable) else None ) post_content = InputFilter.filter_control_chars(form.get_value("dpost")) post_preview = re.sub("(\\n)+", " ", FormTags.sanitize(post_content)) if (len(post_preview) > 255): post_preview = "{0} ...".format(post_preview[:251]) topic_data = { "time_sortable": topic_timestamp, "title": FormTags.encode(topic_title), "tag": topic_tag, "author_ip": self.request.get_client_host(), "description": topic_description } user_profile = (None if (session is None) else session.get_user_profile()) if (user_profile is not None): topic_data['author_id'] = user_profile.get_id() post_data = { "time_sortable": topic_timestamp, "title": FormTags.encode(topic_title), "author_ip": self.request.get_client_host(), "content": FormTags.encode(post_content) } if (user_profile is not None): post_data['author_id'] = user_profile.get_id() with TransactionContext(): # topic.set_data_attributes(**topic_data) post.set_data_attributes(**post_data) if (is_list): _list.add_topic(topic, post, post_preview) elif (is_datalinker_entry): _list.add_entry(topic) topic.add_post(post, post_preview) topic.save() post.save() # pid = post.get_id() tid_d = topic.get_id() DatabaseTasks.get_instance().add("dNG.pas.discuss.Topic.onAdded.{0}".format(tid_d), "dNG.pas.discuss.Topic.onAdded", 1, list_id = oid, topic_id = tid_d, post_id = pid) target_iline = target_iline.replace("__id_d__", "{0}".format(tid_d)) target_iline = re.sub("\\_\\_\\w+\\_\\_", "", target_iline) NotificationStore.get_instance().add_completed_info(L10n.get("pas_http_discuss_done_topic_new")) Link.clear_store("servicemenu") redirect_request = PredefinedHttpRequest() redirect_request.set_iline(target_iline) self.request.redirect(redirect_request) # else: # content = { "title": L10n.get("pas_http_discuss_topic_new") } content['form'] = { "object": form, "url_parameters": { "__request__": True, "a": "new-save", "dsd": { "source": source, "target": target } }, "button_title": "pas_core_save" } self.response.init() self.response.set_title(content['title']) self.response.add_oset_content("core.form", content)