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)
