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 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 _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_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 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 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 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_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 execute_form(self, is_save_mode = False):
#
"""
Action for "form"
:since: v0.1.00
"""
form_id = InputFilter.filter_file_path(self.request.get_dsd("fid", ""))
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
target = target_iline
if (target_iline == ""):
#
target_iline = (source_iline
if (source_iline != "") else
"s=file_form;dsd=fid+{0}".format(Link.encode_query_value(form_id))
)
#
Hook.call("dNG.pas.http.l10n.services.FileForm.init", form_id = form_id)
L10n.init("pas_http_file_form")
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
)
file_path_name = path.abspath("{0}/forms/{1}.json".format(Settings.get("path_data"), form_id))
if ((not path.exists(file_path_name))
or (not os.access(file_path_name, os.R_OK))
): raise TranslatableError("pas_http_file_form_not_found", 404)
file_data = JsonFileContent.read(file_path_name)
lang = self.request.get_lang()
if (file_data is None
or (("form_{0}".format(lang) not in file_data) and ("form" not in file_data))
or "execution" not in file_data
or (not isinstance(file_data['execution'], dict))
or "processor" not in file_data['execution']
or (("title_{0}".format(lang) not in file_data) and ("title" not in file_data))
): raise TranslatableException("pas_http_file_form_not_supported")
if (source_iline == ""
and (("html_back_url_{0}".format(lang) not in file_data) and ("html_back_url" not in file_data))
):
#
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("core_back"),
{ "__query__": (file_data["html_back_url_{0}".format(lang)]
if ("html_back_url_{0}".format(lang) in file_data) else
file_data['html_back_url']
)
},
icon = "mini-default-back",
priority = 7
)
#
form_id = InputFilter.filter_control_chars(self.request.get_parameter("form_id"))
form = FormProcessor(form_id)
if (is_save_mode): form.set_input_available()
processor = NamedLoader.get_instance(file_data['execution']['processor'])
if ((not isinstance(processor, AbstractFileFormProcessor))
or (not processor.validate_settings(file_data['execution']))
): raise TranslatableException("pas_http_file_form_not_supported")
form.load_definition(file_data["form_{0}".format(lang)] if ("form_{0}".format(lang) in file_data) else file_data['form'])
if (is_save_mode and form.check()):
#
processor.set_form(form)
processor.set_settings(file_data['execution'])
processor.execute()
target_iline = re.sub("\\_\\_\\w+\\_\\_", "", target_iline)
title = (file_data["title_{0}".format(lang)] if ("title_{0}".format(lang) in file_data) else file_data['title'])
if ("html_done_message_{0}".format(lang) in file_data): html_info = file_data["html_done_message_{0}".format(lang)]
elif ("html_done_message" in file_data): html_info = file_data['html_done_message']
else: html_info = L10n.get("pas_http_core_form_done_message")
NotificationStore.get_instance().add_completed_info(html_info)
Link.clear_store("servicemenu")
redirect_request = PredefinedHttpRequest()
redirect_request.set_iline(target_iline)
self.request.redirect(redirect_request)
#
else:
#
title = (file_data["title_{0}".format(lang)] if ("title_{0}".format(lang) in file_data) else file_data['title'])
if ("html_title_{0}".format(lang) in file_data): html_title = file_data["html_title_{0}".format(lang)]
elif ("html_title" in file_data): html_title = file_data['html_title']
else: html_title = XHtmlFormatting.escape(title)
content = { "title": html_title }
content['form'] = { "object": form,
"url_parameters": { "__request__": True,
"a": "form-save",
"dsd": { "source": source, "target": target }
},
"button_title": "core_continue"
}
self.response.init()
self.response.set_title(title)
self.response.add_oset_content("core.form", content)
def execute_edit(self, is_save_mode = False):
"""
Action for "edit"
: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()
source = source_iline
if (source_iline == ""): source_iline = "m=mp;a=list_root_containers"
target = target_iline
if (target_iline == ""): target_iline = "m=mp;a=list_root_containers;dsd=mcid+__id_d__"
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")
form_id = InputFilter.filter_control_chars(self.request.get_parameter("form_id"))
form = FormProcessor(form_id)
form.set_context({ "form": "edit" })
mp_entry_data = mp_entry.get_data_attributes("title", "resource")
if (is_save_mode): form.set_input_available()
field = TextField("mtitle")
field.set_title(L10n.get("mp_core_container_title"))
field.set_value(mp_entry_data['title'])
field.set_required()
field.set_limits(int(Settings.get("mp_core_container_title_min", 3)))
form.add(field)
field = InfoField("mresource_filepath")
field.set_title(L10n.get("mp_core_container_resource_local_pathname"))
field.set_value(mp_entry_data['resource'])
form.add(field)
if (is_save_mode and form.check()):
mp_entry_title = InputFilter.filter_control_chars(form.get_value("mtitle"))
mp_entry.set_data_attributes(title = mp_entry_title,
resource_title = mp_entry_title
)
mp_entry.save()
resource_id = mp_entry.get_resource_id()
database_tasks = DatabaseTasks.get_instance()
database_tasks.add("dNG.pas.upnp.Resource.onUpdated.{0}".format(cid), "dNG.pas.upnp.Resource.onUpdated", 1, resource_id = resource_id)
database_tasks.add("dNG.pas.upnp.Resource.onRootContainerUpdated.{0}".format(cid), "dNG.pas.upnp.Resource.onRootContainerUpdated", 1, container_id = resource_id)
target_iline = target_iline.replace("__id_d__", "{0}".format(cid))
target_iline = re.sub("\\_\\w+\\_\\_", "", target_iline)
NotificationStore.get_instance().add_completed_info(L10n.get("mp_core_done_root_container_edit"))
Link.clear_store("servicemenu")
redirect_request = PredefinedHttpRequest()
redirect_request.set_iline(target_iline)
self.request.redirect(redirect_request)
else:
content = { "title": L10n.get("mp_core_root_container_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 get_index(self):
"""
Action for "index"
:since: v1.0.0
"""
dfile_chained = (self.request.get_parameter_chained("dfile")
if (self.request.is_supported("parameters_chained")) else
None
)
dfile = InputFilter.filter_file_path(self.request.get_parameter("dfile", ""))
file_path_name = ""
self.response.set_header("X-Robots-Tag", "noindex")
if (dfile_chained is not None): file_path_name = dfile_chained
elif (dfile != ""): file_path_name = "{0}/assets/{1}".format(Settings.get("path_data"), dfile)
if (file_path_name == ""): raise TranslatableError("pas_http_core_404", 404)
vfs_object = Implementation.load_vfs_url("file:///{0}".format(file_path_name))
if (not vfs_object.is_valid):
raise TranslatableError("pas_http_core_404", 404, "'{0}' not found".format(file_path_name))
#
is_last_modified_supported = (Settings.get("pas_http_site_cache_modification_check", True))
is_modified = True
last_modified_on_server = 0
if (is_last_modified_supported
and (not vfs_object.is_supported("filesystem_path_name"))
): raise TranslatableError("pas_http_core_500", 500)
if (is_last_modified_supported and self.request.get_header("If-Modified-Since") is not None):
last_modified_on_client = RfcBasics.get_rfc7231_timestamp(self.request.get_header("If-Modified-Since").split(";")[0])
if (last_modified_on_client > -1):
last_modified_on_server = int(os.stat(vfs_object.filesystem_path_name).st_mtime)
if (last_modified_on_server <= last_modified_on_client):
is_modified = False
self.response.content_uncachable = False
self.response.send_only_headers = True
self.response.init(True)
self.response.set_header("HTTP", "HTTP/2.0 304 Not Modified", True)
self.response.set_expires_relative(+63072000)
self.response.last_modified = last_modified_on_server
self.response.raw_data = ""
#
#
#
if (is_modified):
re_tsc_result = re.search("\\.tsc\\.(min\\.)?(css|js|svg)$", file_path_name, re.I)
self.response.content_uncachable = (re_tsc_result is not None)
self.response.init(True)
if (is_last_modified_supported):
if (last_modified_on_server < 1):
last_modified_on_server = int(os.stat(vfs_object.filesystem_path_name).st_mtime)
#
self.response.last_modified = last_modified_on_server
#
if (re_tsc_result is not None):
file_extension = re_tsc_result.group(2)
if (file_extension == "css"): self.response.set_header("Content-Type", "text/css")
elif (file_extension == "js"): self.response.set_header("Content-Type", "text/javascript")
elif (file_extension == "svg"): self.response.set_header("Content-Type", "text/svg+xml")
parser = AssetParser()
self.response.raw_data = parser.render(file_path_name)
else:
self.response.set_expires_relative(+63072000)
Streaming.handle_url(self.request, File(), "file:///{0}".format(file_path_name), self.response)
def execute_list(self):
"""
Action for "list"
:since: v0.2.00
"""
cid = InputFilter.filter_file_path(self.request.get_dsd("ccid", ""))
page = InputFilter.filter_int(self.request.get_dsd("cpage", 1))
if (cid == ""): cid = Settings.get("pas_http_contentor_category_default", "")
L10n.init("pas_http_contentor")
L10n.init("pas_http_datalinker")
try: category = Category.load_id(cid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_contentor_cid_invalid", 404, _exception = handled_exception)
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
if (session is not None): category.set_permission_session(session)
if (not category.is_readable()):
if (session is None or session.get_user_profile() is None): raise TranslatableError("pas_http_contentor_cid_invalid", 404)
else: 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")
if (category.is_writable()):
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_contentor_document_new"),
{ "m": "contentor", "s": "document", "a": "new", "dsd": { "ccid": cid } },
icon = "mini-default-option",
priority = 3
)
#
if (category.is_manageable()):
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_contentor_category_manage"),
{ "m": "contentor", "s": "category", "a": "manage", "dsd": { "ccid": cid } },
icon = "mini-default-option",
priority = 3
)
#
category_data = category.get_data_attributes("id", "id_main", "title", "time_sortable", "sub_entries", "entry_type")
content = { "id": category_data['id'],
"title": category_data['title'],
"time": category_data['time_sortable'],
"sub_entries_count": category_data['sub_entries']
}
if (category_data['sub_entries'] > 0): content['sub_entries'] = { "id": category_data['id'], "page": page }
category_parent = category.load_parent()
if (category_parent is not None
and ((not isinstance(category_parent, OwnableInstance))
or category_parent.is_readable_for_session_user(session)
)
):
category_parent_data = category_parent.get_data_attributes("id", "id_main", "title")
if (category_parent_data['id'] != cid):
content['parent'] = { "id": category_parent_data['id'],
"main_id": category_parent_data['id_main'],
"title": category_parent_data['title']
}
#
#
self.response.init(True)
self.response.set_expires_relative(+15)
self.response.set_title(category_data['title'])
self.response.add_oset_content("contentor.{0}_list".format(category_data['entry_type']), content)
if (self.response.is_supported("html_canonical_url")):
link_parameters = { "__virtual__": "/contentor/view",
"dsd": { "ccid": cid, "cpage": page }
}
self.response.set_html_canonical_url(Link().build_url(Link.TYPE_VIRTUAL_PATH, link_parameters))
def execute_view(self):
"""
Action for "view"
:since: v0.2.00
"""
did = InputFilter.filter_file_path(self.request.get_dsd("cdid", ""))
L10n.init("pas_http_contentor")
L10n.init("pas_http_datalinker")
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_readable()):
if (session is None or session.get_user_profile() is None): raise TranslatableError("pas_http_contentor_did_invalid", 404)
else: 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")
if (document.is_manageable()):
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_contentor_document_edit"),
{ "m": "contentor", "s": "document", "a": "edit", "dsd": { "cdid": did } },
icon = "mini-default-option",
priority = 3
)
#
document_parent = document.load_parent()
if (document_parent is None and document.is_main_entry()): document_parent = document
is_category = isinstance(document_parent, Category)
if (isinstance(document_parent, OwnableInstance)):
if (not document_parent.is_readable_for_session_user(session)): raise TranslatableError("core_access_denied", 403)
if (document_parent.is_writable_for_session_user(session)):
document_parent_id = document_parent.get_id()
dsd_parameters = ({ "ccid": document_parent_id }
if (is_category) else
{ "coid": did }
)
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_contentor_document_new"),
{ "m": "contentor", "s": "document", "a": "new", "dsd": dsd_parameters },
icon = "mini-default-option",
priority = 3
)
#
if (is_category and document_parent.is_manageable_for_session_user(session)):
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_contentor_category_manage"),
{ "m": "contentor", "s": "category", "a": "manage", "dsd": { "ccid": document_parent_id } },
icon = "mini-default-option",
priority = 3
)
#
#
document_data = document.get_data_attributes("id",
"id_main",
"title",
"time_sortable",
"sub_entries",
"sub_entries_type",
"content",
"author_id",
"author_ip",
"time_published",
"entry_type",
"description"
)
content = { "id": document_data['id'],
"title": document_data['title'],
"sub_entries_count": document_data['sub_entries'],
"author": { "id": document_data['author_id'], "ip": document_data['author_ip'] },
"content": { "content": document_data['content'], "main_id": document_data['id_main'] },
"time_published": document_data['time_published']
}
if (document_data['time_published'] != document_data['time_sortable']): content['time_updated'] = document_data['time_sortable']
document_parent_data = None
if (document_parent is not None
and ((not isinstance(document_parent, OwnableInstance))
or document_parent.is_readable_for_session_user(session)
)
): document_parent_data = document_parent.get_data_attributes("id", "id_main", "title")
if (document_data['sub_entries'] > 0 or document_parent_data is not None):
content['sub_entries'] = { "type": document_data['sub_entries_type'], "id": document_data['id'] }
if (document_parent_data is not None):
content['sub_entries']['parent_id'] = document_parent_data['id']
content['sub_entries']['parent_main_id'] = document_parent_data['id_main']
content['sub_entries']['parent_title'] = document_parent_data['title']
#
#
self.response.init(True)
self.response.set_title(document_data['title'])
self.response.set_expires_relative(+30)
self.response.set_last_modified(document_data['time_sortable'])
self.response.add_oset_content("contentor.{0}_document".format(document_data['entry_type']), content)
if (self.response.is_supported("html_canonical_url")):
link_parameters = { "__virtual__": "/contentor/view",
"dsd": { "cdid": did }
}
self.response.set_html_canonical_url(Link().build_url(Link.TYPE_VIRTUAL_PATH, link_parameters))
#
if (self.response.is_supported("html_page_description")
and document_data['description'] != ""
): self.response.set_html_page_description(document_data['description'])
def execute_edit(self, is_save_mode = False):
#
"""
Action for "edit"
:since: v0.1.00
"""
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()
source = source_iline
if (source_iline == ""): source_iline = "m=discuss;dsd=dpid+{0}".format(Link.encode_query_value(pid))
target = target_iline
if (target_iline == ""): target_iline = source_iline
L10n.init("pas_http_discuss")
try: post = _Post.load_id(pid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_discuss_pid_invalid", 404, _exception = handled_exception)
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
if (session is not None): post.set_permission_session(session)
if (not post.is_writable()): raise TranslatableError("core_access_denied", 403)
post_parent = post.load_parent()
if (isinstance(post_parent, OwnableInstance) and (not post_parent.is_writable_for_session_user(session))): raise TranslatableError("core_access_denied", 403)
topic = (post_parent
if (isinstance(post_parent, Topic)) else
None
)
topic_parent = None
if (topic is not None):
#
topic_parent = topic.load_parent()
if (isinstance(topic_parent, OwnableInstance) and (not topic_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")
post_data = post.get_data_attributes("title", "content")
form_id = InputFilter.filter_control_chars(self.request.get_parameter("form_id"))
form = FormProcessor(form_id)
if (is_save_mode): form.set_input_available()
field = TextField("dtitle")
field.set_title(L10n.get("pas_http_discuss_post_title"))
field.set_value(post_data['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)
field = FormTagsTextareaField("dpost")
field.set_title(L10n.get("pas_http_discuss_post_content"))
field.set_value(post_data['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()):
#
post_title = InputFilter.filter_control_chars(form.get_value("dtitle"))
post_content = InputFilter.filter_control_chars(form.get_value("dpost"))
post.set_data_attributes(time_sortable = time(),
title = post_title,
content = FormTags.encode(post_content)
)
post.save()
oid = post_parent.get_id()
lid = (None if (topic_parent is None) else topic_parent.get_id())
DatabaseTasks.get_instance().add("dNG.pas.discuss.Post.onUpdated.{0}".format(pid), "dNG.pas.discuss.Post.onUpdated", 1, list_id = lid, topic_id = oid, post_id = pid)
target_iline = target_iline.replace("__id_d__", "{0}".format(pid))
target_iline = re.sub("\\_\\_\\w+\\_\\_", "", target_iline)
NotificationStore.get_instance().add_completed_info(L10n.get("pas_http_discuss_done_post_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_discuss_post_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_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)
def execute_list(self):
#
"""
Action for "list"
:since: v0.1.00
"""
lid = InputFilter.filter_file_path(self.request.get_dsd("dlid", ""))
page = InputFilter.filter_int(self.request.get_dsd("dpage", 1))
sort_value = InputFilter.filter_control_chars(self.request.get_dsd("dsort", ""))
if (lid == ""): lid = Settings.get("pas_http_discuss_list_default", "")
L10n.init("pas_http_datalinker")
L10n.init("pas_http_discuss")
L10n.init("pas_http_subscription")
try: _list = List.load_id(lid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_discuss_lid_invalid", 404, _exception = handled_exception)
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
if (session is not None): _list.set_permission_session(session)
if (not _list.is_readable()):
#
if (session is None or session.get_user_profile() is None): raise TranslatableError("pas_http_discuss_lid_invalid", 404)
else: 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")
is_hybrid_list = _list.is_hybrid_list()
if (is_hybrid_list and _list.is_writable()):
#
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_discuss_topic_new"),
{ "m": "discuss", "s": "topic", "a": "new", "dsd": { "dlid": lid } },
icon = "mini-default-option",
priority = 3
)
#
subscription_handler = (_list.get_subscription_handler() if (is_hybrid_list) else None)
if (subscription_handler is not None and subscription_handler.is_subscribable_for_session_user(session)):
#
source = "m=discuss;dsd=dlid+{0}++dpage+{1}".format(lid, page)
subscription_dsd = { "oid": lid, "source": source }
if (subscription_handler.is_subscribed_by_session_user(session)):
#
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_subscription_unsubscribe"),
{ "m": "subscription", "s": "datalinker", "a": "unsubscribe", "dsd": subscription_dsd },
icon = "mini-default-option",
priority = 3
)
#
else:
#
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_subscription_subscribe"),
{ "m": "subscription", "s": "datalinker", "a": "subscribe", "dsd": subscription_dsd },
icon = "mini-default-option",
priority = 3
)
#
#
if (_list.is_manageable()):
#
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_discuss_list_manage"),
{ "m": "discuss", "s": "list", "a": "manage", "dsd": { "dlid": lid } },
icon = "mini-default-option",
priority = 3
)
#
list_data = _list.get_data_attributes("id",
"id_main",
"title",
"time_sortable",
"sub_entries",
"hybrid_list",
"description",
"topics",
"posts"
)
content = { "id": list_data['id'],
"title": list_data['title'],
"description": list_data['description'],
"time": list_data['time_sortable'],
"topics": _list.get_total_topics_count(),
"posts": _list.get_total_posts_count()
}
if (list_data['sub_entries'] > 0):
#
entry_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_OSET,
"oset_template_name": "discuss.list_column",
"oset_row_attributes": [ "id", "title", "description" ]
}
latest_post_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_OSET,
"oset_template_name": "discuss.latest_post_column",
"oset_row_attributes": [ "latest_timestamp",
"latest_topic_id",
"latest_author_id",
"latest_preview"
]
}
table = DataLinkerTable(_list)
table.add_column("entry",
L10n.get("pas_http_discuss_list"),
30,
sort_key = "title",
renderer = entry_renderer_attributes
)
table.add_column("total_topics",
L10n.get("pas_http_discuss_topics"),
10,
renderer = { "type": DataLinkerTable.COLUMN_RENDERER_SAFE_CONTENT,
"css_text_align": "center"
}
)
table.add_column("total_posts",
L10n.get("pas_http_discuss_posts"),
10,
renderer = { "type": DataLinkerTable.COLUMN_RENDERER_SAFE_CONTENT,
"css_text_align": "center"
}
)
table.add_column("latest_post",
L10n.get("pas_http_discuss_latest_post"),
50,
renderer = latest_post_renderer_attributes
)
table.disable_sort("total_topics", "total_posts", "latest_post")
table.set_limit(15)
hookable_settings = HookableSettings("dNG.pas.http.discuss.List.getLimit",
id = list_data['id']
)
limit = hookable_settings.get("pas_http_discuss_list_limit", 20)
content['sub_entries'] = { "object": table }
if (not is_hybrid_list):
#
content['sub_entries']['dsd_page_key'] = "dpage"
content['sub_entries']['page'] = page
table.set_limit(limit)
content['sub_entries']['dsd_sort_key'] = "dsort"
content['sub_entries']['sort_value'] = sort_value
#
#
if (is_hybrid_list and list_data['topics'] > 0):
#
topic_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_OSET,
"oset_template_name": "discuss.topic_column",
"oset_row_attributes": [ "id", "title", "description" ]
}
latest_post_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_OSET,
"oset_template_name": "discuss.last_post_column",
"oset_row_attributes": [ "time_sortable",
"last_id_author",
"last_preview"
]
}
table = DataLinkerTable(_list)
table.add_column("topic",
L10n.get("pas_http_discuss_topic"),
40,
sort_key = "title",
renderer = topic_renderer_attributes
)
table.add_column("posts",
L10n.get("pas_http_discuss_posts"),
10,
renderer = { "type": DataLinkerTable.COLUMN_RENDERER_SAFE_CONTENT,
"css_text_align": "center"
}
)
table.add_column("latest_post",
L10n.get("pas_http_discuss_latest_post"),
50,
sort_key = "time_sortable",
renderer = latest_post_renderer_attributes
)
table.set_limit(15)
table.set_sort_context("DiscussTopic")
table.set_source_callbacks(_list.get_topics, _list.get_topics_count)
content['topic_entries'] = { "object": table,
"dsd_page_key": "dpage",
"page": page,
"dsd_sort_key": "dsort",
"sort_value": sort_value
}
#
list_parent = _list.load_parent()
if (list_parent is not None
and ((not isinstance(list_parent, OwnableInstance))
or list_parent.is_readable_for_session_user(session)
)
):
#
list_parent_data = list_parent.get_data_attributes("id", "id_main", "title")
if (list_parent_data['id'] != lid):
#
content['parent'] = { "id": list_parent_data['id'],
"main_id": list_parent_data['id_main'],
"title": list_parent_data['title']
}
#
#
self.response.init(True)
self.response.set_expires_relative(+15)
self.response.set_title(list_data['title'])
self.response.add_oset_content(("discuss.hybrid_list" if (is_hybrid_list) else "discuss.list"),
content
)
if (self.response.is_supported("html_canonical_url")):
#
link_parameters = { "__virtual__": "/discuss/view/list",
"dsd": { "dlid": lid, "dpage": page, "dsort": sort_value }
}
self.response.set_html_canonical_url(Link().build_url(Link.TYPE_VIRTUAL_PATH, link_parameters))
def execute_topic(self):
#
"""
Action for "topic"
:since: v0.1.00
"""
tid = InputFilter.filter_file_path(self.request.get_dsd("dtid", ""))
page = InputFilter.filter_int(self.request.get_dsd("dpage", 1))
L10n.init("pas_http_datalinker")
L10n.init("pas_http_discuss")
try: topic = Topic.load_id(tid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_discuss_tid_invalid", 404, _exception = handled_exception)
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
if (session is not None): topic.set_permission_session(session)
if (not topic.is_readable()):
#
if (session is None or session.get_user_profile() is None): raise TranslatableError("pas_http_discuss_tid_invalid", 404)
else: 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")
if (topic.is_writable()):
#
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_discuss_post_new"),
{ "m": "discuss", "s": "post", "a": "new", "dsd": { "dtid": tid } },
icon = "mini-default-option",
priority = 3
)
#
subscription_handler = topic.get_subscription_handler()
if (subscription_handler is not None and subscription_handler.is_subscribable_for_session_user(session)):
#
if (subscription_handler.is_subscribed_by_session_user(session)):
#
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_discuss_topic_unsubscribe"),
{ "m": "discuss", "s": "topic_subscription", "a": "unsubscribe", "dsd": { "dtid": tid } },
icon = "mini-default-option",
priority = 3
)
#
else:
#
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_discuss_topic_subscribe"),
{ "m": "discuss", "s": "topic_subscription", "a": "subscribe", "dsd": { "dtid": tid } },
icon = "mini-default-option",
priority = 3
)
#
#
topic_parent = topic.load_parent()
is_list = isinstance(topic_parent, List)
if (isinstance(topic_parent, OwnableInstance)):
#
if (not topic_parent.is_readable_for_session_user(session)): raise TranslatableError("core_access_denied", 403)
if (topic_parent.is_writable_for_session_user(session)):
#
topic_parent_id = topic_parent.get_id()
dsd_parameters = ({ "dlid": topic_parent_id }
if (is_list) else
{ "doid": tid }
)
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_discuss_topic_new"),
{ "m": "discuss", "s": "topic", "a": "new", "dsd": dsd_parameters },
icon = "mini-default-option",
priority = 3
)
#
if (is_list and topic_parent.is_manageable_for_session_user(session)):
#
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_discuss_list_manage"),
{ "m": "discuss", "s": "list", "a": "manage", "dsd": { "dlid": topic_parent_id } },
icon = "mini-default-option",
priority = 3
)
#
#
topic_data = topic.get_data_attributes("id",
"id_main",
"title",
"time_sortable",
"sub_entries",
"sub_entries_type",
"author_id",
"author_ip",
"posts",
"description",
"time_published"
)
content = { "id": topic_data['id'],
"title": topic_data['title'],
"author": { "id": topic_data['author_id'], "ip": topic_data['author_ip'] },
"posts": topic_data['posts'],
"description": topic_data['description'],
"time_published": topic_data['time_published'],
"post_entries": { "id": topic_data['id'], "main_id": topic_data['id_main'], "page": page }
}
if (topic_data['time_published'] != topic_data['time_sortable']):
#
content['last_timestamp'] = topic_data['time_sortable']
#
if (topic_data['sub_entries'] > 0):
#
content['sub_entries'] = { "type": topic_data['sub_entries_type'], "id": topic_data['id'] }
#
if (topic_parent is not None
and ((not isinstance(topic_parent, OwnableInstance))
or topic_parent.is_readable_for_session_user(session)
)
):
#
topic_parent_data = topic_parent.get_data_attributes("id", "id_main", "title")
content['parent'] = { "id": topic_parent_data['id'],
"main_id": topic_parent_data['id_main'],
"title": topic_parent_data['title']
}
#
self.response.init(True)
self.response.set_title(topic_data['title'])
self.response.set_expires_relative(+15)
self.response.set_last_modified(topic_data['time_sortable'])
self.response.add_oset_content("discuss.topic", content)
if (self.response.is_supported("html_canonical_url")):
#
link_parameters = { "__virtual__": "/discuss/view/topic",
"dsd": { "dtid": tid, "dpage": page }
}
self.response.set_html_canonical_url(Link().build_url(Link.TYPE_VIRTUAL_PATH, link_parameters))
#
if (self.response.is_supported("html_page_description")
and topic_data['description'] != ""
): self.response.set_html_page_description(topic_data['description'])
#
#
##j## EOF
def execute_edit(self, is_save_mode = False):
"""
Action for "edit"
:since: v0.2.00
"""
pid = InputFilter.filter_file_path(self.request.get_dsd("upid", ""))
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=user;s=profile;dsd=upid+{0}".format(Link.encode_query_value(pid))
target = target_iline
if (target_iline == ""): target_iline = source_iline
L10n.init("pas_http_user")
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
session_user_is_administrator = False
session_user_pid = None
session_user_profile = None
if (session is not None):
session_user_pid = session.get_user_id()
session_user_profile = session.get_user_profile()
if (session_user_profile is not None):
if (session_user_profile.is_valid()): session_user_is_administrator = session_user_profile.is_type("ad")
if (pid == ""): pid = session_user_pid
#
#
if (pid == ""): raise TranslatableError("pas_http_user_pid_invalid", 404)
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
if (user_profile_class is None): raise TranslatableException("core_unknown_error")
try: user_profile = user_profile_class.load_id(pid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_user_pid_invalid", 404, _exception = handled_exception)
if ((not session_user_is_administrator)
and (pid != session_user_pid or (not user_profile.is_valid()))
): 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
)
edit_source = ("m=user;s=profile;a=edit;dsd=upid+{0}".format(Link.encode_query_value(pid)) if (source == "") else source)
if (not user_profile.is_type("ex")):
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
(L10n.get("pas_http_user_change_username_or_password")
if (Settings.get("pas_http_user_change_username_allowed", True)) else
L10n.get("pas_http_user_change_password")
),
{ "m": "user", "s": "profile", "a": "change-username-password", "dsd": { "source": edit_source, "target": target } },
icon = "mini-default-option",
priority = 3
)
if (not session_user_is_administrator):
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_user_change_email"),
{ "m": "user", "s": "profile", "a": "change-email", "dsd": { "source": edit_source, "target": target } },
icon = "mini-default-option",
priority = 3
)
#
elif (Settings.get("pas_http_user_change_username_allowed", True)):
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_user_change_username"),
{ "m": "user", "s": "profile", "a": "change-username", "dsd": { "source": edit_source, "target": target } },
icon = "mini-default-option",
priority = 3
)
#
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)
user_profile_data = user_profile.get_data_attributes("name", "email", "signature", "title")
email = user_profile_data['email']
title = user_profile_data['title']
if (is_save_mode): form.set_input_available()
if (session_user_is_administrator):
field = EMailField("uemail")
field.set_title(L10n.get("pas_http_user_email"))
field.set_value(email)
field.set_required()
field.set_limits(_max = 255)
form.add(field)
else:
field = InfoField("uemail")
field.set_title(L10n.get("pas_http_user_email"))
field.set_value(email)
form.add(field)
#
field = FormTagsTextareaField("usignature")
field.set_title(L10n.get("pas_http_user_signature"))
field.set_value(user_profile_data['signature'])
field.set_size(FormTagsTextareaField.SIZE_SMALL)
field.set_limits(_max = 255)
form.add(field)
if (session_user_is_administrator):
field = FormTagsTextField("utitle")
field.set_title(L10n.get("pas_http_user_title"))
field.set_value(title)
field.set_limits(_max = 255)
form.add(field)
#
if (is_save_mode and form.check()):
if (session_user_is_administrator): email = InputFilter.filter_control_chars(form.get_value("uemail"))
signature = InputFilter.filter_control_chars(form.get_value("usignature"))
if (session_user_is_administrator): title = InputFilter.filter_control_chars(form.get_value("utitle"))
original_user_profile_data = user_profile_data.copy()
user_profile_data_changed = { "signature": FormTags.encode(signature) }
if (session_user_is_administrator):
user_profile_data_changed['email'] = email
user_profile_data_changed['title'] = FormTags.encode(title)
#
user_profile.set_data_attributes(**user_profile_data_changed)
user_profile.save()
DatabaseTasks.get_instance().add("dNG.pas.user.Profile.onEdited.{0}".format(user_profile_data['name']),
"dNG.pas.user.Profile.onEdited",
1,
user_profile_id = pid,
user_profile_data_changed = user_profile_data_changed,
original_user_profile_data = original_user_profile_data
)
target_iline = target_iline.replace("__id_d__", pid)
target_iline = re.sub("\\_\\_\\w+\\_\\_", "", target_iline)
NotificationStore.get_instance().add_completed_info(L10n.get("pas_http_user_done_change_profile"))
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_user_title_change_profile") }
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_view(self):
"""
Action for "view"
:since: v0.2.00
"""
pid = InputFilter.filter_file_path(self.request.get_dsd("upid", ""))
source_iline = InputFilter.filter_control_chars(self.request.get_dsd("source", "")).strip()
source = source_iline
if (source_iline == ""): source_iline = "m=user;a=services"
L10n.init("pas_http_user")
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
session_user_is_administrator = False
session_user_pid = None
session_user_profile = None
if (session is not None):
session_user_pid = session.get_user_id()
session_user_profile = session.get_user_profile()
if (session_user_profile is not None and session_user_profile.is_valid()):
session_user_is_administrator = session_user_profile.is_type("ad")
if (pid == ""): pid = session_user_pid
else: session_user_pid = None
#
if (pid == ""): raise TranslatableError("pas_http_user_pid_invalid", 404)
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
if (user_profile_class is None): raise TranslatableException("core_unknown_error")
try: user_profile = user_profile_class.load_id(pid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_user_pid_invalid", 404, _exception = handled_exception)
if (user_profile.is_deleted()): raise TranslatableError("pas_http_user_pid_invalid", 404)
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 (session_user_pid is not None):
Link.set_store("servicemenu",
Link.TYPE_RELATIVE_URL,
L10n.get("pas_http_user_profile_edit"),
{ "m": "user", "s": "profile", "a": "edit", "dsd": { "source": source } },
icon = "mini-default-option",
priority = 3
)
#
user_profile_data = user_profile.get_data_attributes("type",
"name",
"email",
"email_public",
"title",
"signature",
"registration_ip",
"registration_time",
"lastvisit_ip",
"lastvisit_time"
)
view = FormView()
if (user_profile_data['email'] != ""
and session_user_profile is not None
and session_user_profile.is_valid()
):
field = InfoField("uemail")
field.set_title(L10n.get("pas_http_user_email"))
if (session_user_is_administrator or user_profile_data['email_public']): field.set_value(user_profile_data['email'])
else: field.set_value(L10n.get("pas_http_user_send_email"))
field.set_link(Link().build_url(Link.TYPE_RELATIVE_URL,
{ "m": "user", "s": "email", "dsd": { "upid": pid } }
)
)
view.add(field)
#
if (user_profile_data['registration_time'] > 0):
field = InfoField("uregistration_time")
field.set_title(L10n.get("pas_http_user_registration_time"))
field.set_value(DateTime.format_l10n(DateTime.TYPE_DATE_TIME_SHORT, user_profile_data['registration_time']))
view.add(field)
if (session_user_is_administrator and user_profile_data['registration_ip'] != ""):
field = InfoField("uregistration_ip")
field.set_title(L10n.get("pas_http_user_registration_ip"))
field.set_value(user_profile_data['registration_ip'])
view.add(field)
#
#
if (user_profile_data['lastvisit_time'] > 0):
field = InfoField("ulastvisit_time")
field.set_title(L10n.get("pas_http_user_lastvisit_time"))
field.set_value(DateTime.format_l10n(DateTime.TYPE_DATE_TIME_SHORT, user_profile_data['lastvisit_time']))
view.add(field)
if (session_user_is_administrator and user_profile_data['lastvisit_ip'] != ""):
field = InfoField("ulastvisit_ip")
field.set_title(L10n.get("pas_http_user_lastvisit_ip"))
field.set_value(user_profile_data['lastvisit_ip'])
view.add(field)
#
#
content = { "title": user_profile_data['name'],
"username": user_profile_data['name'],
"usertitle": user_profile_data['title'],
"signature": user_profile_data['signature'],
"details_form_view": { "object": view }
}
self.response.init()
self.response.set_title(user_profile_data['name'])
self.response.add_oset_content("user.profile", 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_latest_sub_documents(self):
"""
Action for "latest_sub_documents"
:since: v0.2.00
"""
cid = InputFilter.filter_file_path(self.request.get_dsd("ccid", ""))
source = "m=contentor;s=category;a=latest_sub_documents;dsd=ccid+{0}".format(Link.encode_query_value(cid))
if (cid == ""): cid = Settings.get("pas_http_contentor_category_default", "")
L10n.init("pas_http_contentor")
L10n.init("pas_http_datalinker")
try: category = _Category.load_id(cid)
except NothingMatchedException as handled_exception: raise TranslatableError("pas_http_contentor_cid_invalid", 404, _exception = handled_exception)
session = (self.request.get_session() if (self.request.is_supported("session")) else None)
if (session is not None): category.set_permission_session(session)
if (not category.is_readable()):
if (session is None or session.get_user_profile() is None): raise TranslatableError("pas_http_contentor_cid_invalid", 404)
else: 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")
if (category.is_manageable()):
Link.set_store("servicemenu",
(Link.TYPE_RELATIVE_URL | Link.TYPE_JS_REQUIRED),
L10n.get("pas_http_contentor_category_manage"),
{ "m": "contentor", "s": "category", "a": "manage", "dsd": { "ccid": cid, "source": source } },
icon = "mini-default-option",
priority = 3
)
#
category_data = category.get_data_attributes("id", "id_main", "title", "time_sortable", "categories", "entry_type")
title = "{0}{1}{2}".format(L10n.get("pas_http_contentor_latest_sub_documents_1"),
category_data['title'],
L10n.get("pas_http_contentor_latest_sub_documents_2")
)
content = { "id": category_data['id'],
"title": title,
"time": category_data['time_sortable'],
"categories_count": category_data['categories']
}
if (category_data['categories'] > 0):
content['categories_list'] = [ ]
hookable_settings = HookableSettings("dNG.pas.http.contentor.DocumentList.getLimit",
id = cid,
type = category_data['entry_type']
)
limit = hookable_settings.get("pas_http_contentor_list_{0}_document_limit".format(category_data['entry_type']),
20
)
limit = ceil(limit / category_data['categories'])
title_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_CALLBACK_OSET,
"callback": self._get_title_cell_content,
"oset_template_name": "contentor.title_column",
"oset_row_attributes": [ "id", "title" ]
}
time_sortable_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_OSET,
"oset_template_name": "contentor.time_sortable_column",
"oset_row_attributes": [ "time_sortable", "time_published" ]
}
description_renderer_attributes = { "type": DataLinkerTable.COLUMN_RENDERER_OSET,
"oset_template_name": "contentor.description_column"
}
for sub_category in category.get_categories():
if (sub_category.is_readable_for_session_user(session)):
sub_category_data = sub_category.get_data_attributes("id", "title", "sub_entries")
table = DataLinkerTable(sub_category)
table.add_column("title", L10n.get("pas_http_contentor_document_title"), 35, renderer = title_renderer_attributes)
table.add_column("time_sortable", L10n.get("pas_http_contentor_document_published"), 15, renderer = time_sortable_renderer_attributes)
table.add_column("description", L10n.get("pas_http_contentor_document_description"), 50, renderer = description_renderer_attributes)
table.add_sort_definition("time_sortable", DataLinkerTable.SORT_DESCENDING)
table.disable_sort("description")
table.set_limit(limit)
link = { "m": "contentor", "dsd": { "ccid": sub_category_data['id'] } }
content['categories_list'].append({ "id": sub_category_data['id'],
"title": sub_category_data['title'],
"link": Link().build_url(Link.TYPE_RELATIVE_URL, link),
"sub_entries_count": sub_category_data['sub_entries'],
"object": table
})
#
#
#
category_parent = category.load_parent()
if (category_parent is not None
and ((not isinstance(category_parent, OwnableInstance))
or category_parent.is_readable_for_session_user(session)
)
):
category_parent_data = category_parent.get_data_attributes("id", "id_main", "title")
if (category_parent_data['id'] != cid):
content['parent'] = { "id": category_parent_data['id'],
"main_id": category_parent_data['id_main'],
"title": category_parent_data['title']
}
#
#
self.response.init(True)
self.response.set_expires_relative(+15)
self.response.set_title(title)
self.response.add_oset_content("contentor.latest_sub_documents_list".format(category_data['entry_type']), content)
