def load_cds_id(_id, client_user_agent = None, cds = None, deleted = False):
"""
Load a UPnP resource by CDS ID.
:param _id: UPnP CDS ID
:param client_user_agent: Client user agent
:param cds: UPnP CDS
:param deleted: True to include deleted resources
:return: (object) Resource object; None on error
:since: v0.2.00
"""
_return = None
if (_id == "0" and cds is not None):
_return = NamedLoader.get_instance("dNG.data.upnp.resources.RootContainer")
_return.init_cds_id(_id, client_user_agent, deleted)
elif (_id is not None and "://" in _id):
url_elements = urlsplit(_id)
if (url_elements.scheme != ""):
resource_class_name = "".join([ word.capitalize() for word in url_elements.scheme.split("-") ])
resource = NamedLoader.get_instance("dNG.data.upnp.resources.{0}".format(resource_class_name), False)
if (isinstance(resource, Resource) and resource.init_cds_id(_id, client_user_agent, deleted)): _return = resource
#
#
return _return
def after_apply_schema(params, last_return = None):
"""
Called for "dNG.pas.Database.applySchema.after"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
if (issubclass(user_profile_class, Profile)):
db_user_profile_class = NamedLoader.get_class("dNG.database.instances.UserProfile")
Schema.apply_version(db_user_profile_class)
cli = InteractiveCli.get_instance()
if (isinstance(cli, InteractiveCli)
and hasattr(cli, "is_cli_setup")
and cli.is_cli_setup()
): _ensure_administrative_user_account()
#
return last_return
def _on_run(self, args):
"""
Callback for execution.
:param args: Parsed command line arguments
:since: v0.2.00
"""
# pylint: disable=attribute-defined-outside-init
Settings.read_file("{0}/settings/pas_global.json".format(Settings.get("path_data")))
Settings.read_file("{0}/settings/pas_core.json".format(Settings.get("path_data")), True)
Settings.read_file("{0}/settings/pas_tasks_daemon.json".format(Settings.get("path_data")), True)
if (args.additional_settings is not None): Settings.read_file(args.additional_settings, True)
if (not Settings.is_defined("pas_tasks_daemon_listener_address")): raise IOException("No listener address defined for the TasksDaemon")
if (args.reload_plugins):
client = BusClient("pas_tasks_daemon")
client.request("dNG.pas.Plugins.reload")
elif (args.stop):
client = BusClient("pas_tasks_daemon")
pid = client.request("dNG.pas.Status.getOSPid")
client.request("dNG.pas.Status.stop")
self._wait_for_os_pid(pid)
else:
self.cache_instance = NamedLoader.get_singleton("dNG.data.cache.Content", False)
if (self.cache_instance is not None): Settings.set_cache_instance(self.cache_instance)
self.log_handler = NamedLoader.get_singleton("dNG.data.logging.LogHandler", False)
if (self.log_handler is not None):
Hook.set_log_handler(self.log_handler)
NamedLoader.set_log_handler(self.log_handler)
#
Hook.load("tasks")
Hook.register("dNG.pas.Status.getOSPid", self.get_os_pid)
Hook.register("dNG.pas.Status.getTimeStarted", self.get_time_started)
Hook.register("dNG.pas.Status.getUptime", self.get_uptime)
Hook.register("dNG.pas.Status.stop", self.stop)
self.server = BusServer("pas_tasks_daemon")
self._set_time_started(time())
if (self.log_handler is not None): self.log_handler.info("TasksDaemon starts listening", context = "pas_tasks")
Hook.call("dNG.pas.Status.onStartup")
Hook.call("dNG.pas.tasks.Daemon.onStartup")
self.set_mainloop(self.server.run)
def _on_run(self, args):
"""
Callback for execution.
:param args: Parsed command line arguments
:since: v0.2.00
"""
Settings.read_file("{0}/settings/pas_global.json".format(Settings.get("path_data")))
Settings.read_file("{0}/settings/pas_core.json".format(Settings.get("path_data")), True)
Settings.read_file("{0}/settings/pas_http.json".format(Settings.get("path_data")), True)
if (args.additional_settings is not None): Settings.read_file(args.additional_settings, True)
if (args.reload_plugins):
client = BusClient("pas_http_bus")
client.request("dNG.pas.Plugins.reload")
elif (args.stop):
client = BusClient("pas_http_bus")
pid = client.request("dNG.pas.Status.getOSPid")
client.request("dNG.pas.Status.stop")
self._wait_for_os_pid(pid)
else:
self.log_handler = NamedLoader.get_singleton("dNG.data.logging.LogHandler", False)
if (self.log_handler is not None):
Hook.set_log_handler(self.log_handler)
NamedLoader.set_log_handler(self.log_handler)
#
self.cache_instance = NamedLoader.get_singleton("dNG.data.cache.Content", False)
if (self.cache_instance is not None): Settings.set_cache_instance(self.cache_instance)
Hook.load("http")
Hook.register("dNG.pas.Status.getOSPid", self.get_os_pid)
Hook.register("dNG.pas.Status.getTimeStarted", self.get_time_started)
Hook.register("dNG.pas.Status.getUptime", self.get_uptime)
Hook.register("dNG.pas.Status.stop", self.stop)
self._set_time_started(time())
http_server = _HttpServer.get_instance()
self.server = BusServer("pas_http_bus")
if (http_server is not None):
Hook.register("dNG.pas.Status.onStartup", http_server.start)
Hook.register("dNG.pas.Status.onShutdown", http_server.stop)
if (self.log_handler is not None): self.log_handler.info("pas.http starts listening", context = "pas_http_site")
Hook.call("dNG.pas.Status.onStartup")
self.set_mainloop(self.server.run)
def load_all(params, last_return = None):
"""
Load and register all SQLAlchemy objects to generate database tables.
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:since: v0.1.00
"""
NamedLoader.get_class("dNG.database.instances.FileCenterEntry")
return last_return
def load_all(params, last_return = None):
"""
Load and register all SQLAlchemy objects to generate database tables.
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
if (issubclass(user_profile_class, Profile)): NamedLoader.get_class("dNG.database.instances.UserProfile")
return last_return
def load_all(params, last_return = None):
"""
Load and register all SQLAlchemy objects to generate database tables.
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
NamedLoader.get_class("dNG.database.instances.DataLinker")
NamedLoader.get_class("dNG.database.instances.DataLinkerMeta")
return last_return
def delete(params, last_return=None):
"""
Called for "dNG.pas.user.Profile.delete"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
# pylint: disable=star-args
if ("username" not in params):
raise ValueException("Missing required argument")
else:
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
try:
user_profile = user_profile_class.load_username(params['username'])
Hook.call("dNG.pas.user.Profile.onDelete",
user_profile_id=user_profile.get_id())
user_profile.delete()
except NothingMatchedException:
pass
#
return last_return
def get_rootdevice(self, identifier):
"""
Returns a UPnP rootdevice for the given identifier.
:param identifier: Parsed UPnP identifier
:return: (object) UPnP rootdevice; None if not found
:since: v0.2.00
"""
_return = None
with self.lock:
if (identifier['class'] == "device" and identifier['usn'] in self.usns):
if (identifier['uuid'] in self.managed_devices):
if (self.log_handler is not None): self.log_handler.debug("{0!r} got request to return the hosted device '{1}'", self, identifier['usn'], context = "pas_upnp")
_return = self.managed_devices[identifier['uuid']]
_return.set_configid(self.configid)
else:
if (self.log_handler is not None): self.log_handler.debug("{0!r} got request to create an object for device '{1}'", self, identifier['usn'], context = "pas_upnp")
_return = (NamedLoader.get_instance("dNG.data.upnp.devices.{0}".format(identifier['type']), False) if (identifier['class'] == "device") else None)
if (_return is None): _return = Device()
if (_return.init_xml_desc(self.usns[identifier['usn']], self.get_desc_xml(identifier)) == False): _return = None
#
#
#
return _return
def get_class(is_not_implemented_class_aware = False):
"""
Returns the persistent tasks implementation class based on the configuration
set.
:param is_not_implemented_class_aware: True to return
"dNG.runtime.NotImplementedClass" instead of None
:return: (object) Tasks implementation class; None if not available
:since: v0.2.00
"""
_return = None
persistent_tasks = Persistent.get_executing_instance()
if (isinstance(persistent_tasks, AbstractPersistent) and persistent_tasks.is_executing_daemon()):
_return = persistent_tasks
else:
persistent_tasks_proxy = NamedLoader.get_singleton("dNG.data.tasks.PersistentProxy")
if (isinstance(persistent_tasks_proxy, AbstractPersistentProxy)
and persistent_tasks_proxy.is_available()
): _return = persistent_tasks_proxy
#
if (_return is None and is_not_implemented_class_aware): _return = NotImplementedClass
return _return
def __init__(self, timeout_retries = 5):
"""
Constructor __init__(Abstract)
:param timeout_retries: Retries before timing out
:since: v0.2.00
"""
SupportsMixin.__init__(self)
self.io_chunk_size = 65536
"""
IO chunk size
"""
self._lock = ThreadLock()
"""
Thread safety lock
"""
self.log_handler = NamedLoader.get_singleton("dNG.data.logging.LogHandler", False)
"""
Retries before timing out
"""
self.stream_size = -1
"""
Requested stream size
"""
self.timeout_retries = (5 if (timeout_retries is None) else timeout_retries)
"""
def delete(params, last_return = None):
"""
Called for "dNG.pas.user.Profile.delete"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
# pylint: disable=star-args
if ("username" not in params): raise ValueException("Missing required argument")
else:
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
try:
user_profile = user_profile_class.load_username(params['username'])
Hook.call("dNG.pas.user.Profile.onDelete", user_profile_id = user_profile.get_id())
user_profile.delete()
except NothingMatchedException: pass
#
return last_return
def _init_host_protocol_info(self):
"""
Initializes the client settings UPnP host based protocol info dictionary if
the UPnP host has been previously defined.
:since: v0.2.00
"""
if (self.host is not None and self.host_protocol_info_dict is None):
with self._lock:
# Thread safety
if (self.host_protocol_info_dict is None):
self.host_protocol_info_dict = { }
control_point = NamedLoader.get_singleton("dNG.net.upnp.ControlPoint")
connection_manager = None
device = control_point.get_rootdevice_for_host(self.host, "MediaRenderer")
if (device is not None): connection_manager = device.get_service("ConnectionManager")
if (connection_manager is not None and connection_manager.is_action_supported("GetProtocolInfo")):
connection_manager_proxy = connection_manager.get_proxy()
protocol_info = connection_manager_proxy.GetProtocolInfo()
supported_list = protocol_info.get("Source", "").split(",")
self.host_protocol_info_dict['upnp_protocol_source_supported_list'] = supported_list
supported_list = protocol_info.get("Sink", "").split(",")
self.host_protocol_info_dict['upnp_protocol_sink_supported_list'] = supported_list
def init_device(self, control_point, udn = None, configid = None):
"""
Initialize a host device.
:return: (bool) Returns true if initialization was successful.
:since: v0.2.00
"""
AbstractDevice.init_device(self, control_point, udn, configid)
self.device_model = "UPnP media server"
self.device_model_desc = "Python based UPnP media server"
self.device_model_url = "https://www.direct-netware.de/redirect?mp;core"
self.device_model_version = "#echo(mpCoreVersion)#"
self.manufacturer = "direct Netware Group"
self.manufacturer_url = "http://www.direct-netware.de"
#service = AvTransport()
#if (service.init_host(self, configid = self.configid)): self.add_service(service)
service = ConnectionManager()
if (service.init_host(self, configid = self.configid)): self.add_service(service)
service = ContentDirectory()
if (service.init_host(self, configid = self.configid)): self.add_service(service)
service = NamedLoader.get_instance("dNG.data.upnp.services.ScheduledRecording", False)
if (service is not None and service.init_host(self, configid = self.configid)): self.add_service(service)
service = XMSMediaReceiverRegistrar()
if (service.init_host(self, configid = self.configid)): self.add_service(service)
return True
def _get_user_profile(self, user_id):
"""
Returns the user profile instance for the given user ID.
:param user_id: User ID
:return: (object) User profile instance; None if not found
:since: v0.2.00
"""
_return = None
if (user_id is not None):
_return = self.permission_user_profile_cache.get(user_id)
if (_return is None):
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
_return = (None if (user_profile_class is None) else user_profile_class.load_id(user_id))
if (_return is not None): self.permission_user_profile_cache[user_id] = _return
#
if (_return is not None and (not _return.is_valid())): _return = None
#
return _return
def after_apply_schema(params, last_return = None):
"""
Called for "dNG.pas.Database.applySchema.after"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
acl_entry_class = NamedLoader.get_class("dNG.database.instances.AclEntry")
Schema.apply_version(acl_entry_class)
permission_class = NamedLoader.get_class("dNG.database.instances.Permission")
Schema.apply_version(permission_class)
return last_return
def after_apply_schema(params, last_return = None):
"""
Called for "dNG.pas.Database.applySchema.after"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
category_class = NamedLoader.get_class("dNG.database.instances.ContentorCategory")
Schema.apply_version(category_class)
document_class = NamedLoader.get_class("dNG.database.instances.ContentorDocument")
Schema.apply_version(document_class)
return last_return
def after_apply_schema(params, last_return = None):
"""
Called for "dNG.pas.Database.applySchema.after"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
datalinker_class = NamedLoader.get_class("dNG.database.instances.DataLinker")
Schema.apply_version(datalinker_class)
datalinker_meta_class = NamedLoader.get_class("dNG.database.instances.DataLinkerMeta")
Schema.apply_version(datalinker_meta_class)
return last_return
def load_plugin(plugin, prefix = None):
"""
Load and register all plugins for the given plugin name and prefix (defaults
to "dNG.plugins").
:param plugin: Plugin name
:param prefix: Plugin name prefix
:return: (bool) True on success
:since: v0.2.00
"""
# pylint: disable=no-member
_return = False
if (prefix is None): prefix = "dNG.plugins"
package = "{0}.{1}".format(prefix, plugin)
if (NamedLoader._load_package(package) is not None):
package_path = path.join(Manager._get_loader().get_base_dir(), package.replace(".", path.sep))
if (not os.access(package_path, os.R_OK)): package_path = None
else: package_path = None
if (package_path is not None and path.isdir(package_path)):
for dir_entry in os.listdir(package_path):
if (dir_entry.endswith(".py") and dir_entry != "__init__.py"):
module_name = "{0}.{1}".format(package, dir_entry[:-3])
module = NamedLoader._load_module(module_name)
if (module is not None and hasattr(module, "register_plugin")):
with ExceptionLogTrap("pas_plugins"):
if (package not in Manager._plugins): Manager._plugins[package] = [ ]
if (module_name not in Manager._plugins[package]): Manager._plugins[package].append(module_name)
module.register_plugin()
_return = True
#
#
#
#
#
return _return
def before_apply_schema(params, last_return = None):
"""
Called for "dNG.pas.Database.applySchema.before"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
audio_class = NamedLoader.get_class("dNG.database.instances.MpUpnpAudioResource")
if (audio_class is not None): audio_class.before_apply_schema()
image_class = NamedLoader.get_class("dNG.database.instances.MpUpnpImageResource")
if (image_class is not None): image_class.before_apply_schema()
video_class = NamedLoader.get_class("dNG.database.instances.MpUpnpVideoResource")
if (video_class is not None): video_class.before_apply_schema()
return last_return
def __init__(self):
"""
Constructor __init__(Resources)
:since: v0.2.00
"""
ClientSettingsMixin.__init__(self)
SupportsMixin.__init__(self)
self.criteria_definition = None
"""
UPnP search criteria definition instance
"""
self.executed = False
"""
True if search has been executed and results are ready
"""
self.limit = 50
"""
UPnP resource search results limit
"""
self.limit_max = int(Settings.get("pas_upnp_resource_search_limit_max", 50))
"""
UPnP resource search results limit
"""
self.log_handler = NamedLoader.get_singleton("dNG.data.logging.LogHandler", False)
"""
The LogHandler is called whenever debug messages should be logged or errors
happened.
"""
self.offset = 0
"""
UPnP resource search results offset
"""
self.resources = [ ]
"""
UPnP resources matching the criteria definition
"""
self.total = 0
"""
UPnP resource search results count from all segments
"""
self.root_resource = None
"""
UPnP root resource for searching matches
"""
self.sort_tuples = [ ]
"""
Sort list to be applied
"""
self.supported_features['sortable'] = self._supports_sortable
def run(self):
"""
Task execution
:since: v0.2.00
"""
if (self.__class__.EMAIL_RENDERER is None): raise ValueException("Defined e-mail renderer is invalid")
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
user_profile = user_profile_class.load_username(self.username)
user_profile_data = user_profile.get_data_attributes("name", "lang", "email")
email = self.get_email_recipient()
if (email is None): email = user_profile_data['email']
L10n.init("core", user_profile_data['lang'])
L10n.init("pas_core", user_profile_data['lang'])
L10n.init("pas_http_user", user_profile_data['lang'])
l10n = L10n.get_instance(user_profile_data['lang'])
email_renderer = NamedLoader.get_instance(self.__class__.EMAIL_RENDERER, l10n = l10n)
content = email_renderer.render(user_profile_data, self.vid, self.vid_timeout_days)
subject = self.get_email_subject(l10n)
if (subject is None): subject = l10n.get("pas_http_user_title_verification")
part = Part(Part.TYPE_MESSAGE_BODY, "text/plain", content)
message = Message()
message.add_body(part)
message.set_subject(subject)
message.set_to(Message.format_address(user_profile_data['name'], email))
smtp_client = SmtpClient()
smtp_client.set_message(message)
smtp_client.send()
def after_apply_schema(params, last_return = None):
#
"""
Called for "dNG.pas.Database.applySchema.after"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.1.00
"""
list_class = NamedLoader.get_class("dNG.database.instances.DiscussList")
Schema.apply_version(list_class)
topic_class = NamedLoader.get_class("dNG.database.instances.DiscussTopic")
Schema.apply_version(topic_class)
post_class = NamedLoader.get_class("dNG.database.instances.DiscussPost")
Schema.apply_version(post_class)
return last_return
def load_encapsulating_entry(_id, client_user_agent = None, cds = None, deleted = False):
"""
Loads a matching MpEntry for the given MpEntry instance based ID or VFS URL.
:param _id: MpEntry instance based ID or VFS URL
:param client_user_agent: Client user agent
:param cds: UPnP CDS
:param deleted: True to include deleted resources
:return: (object) Resource object; None on error
:since: v0.2.00
"""
if (_id is None): raise TypeException("MpEntry ID or VFS URL given is invalid")
_return = None
if ("://" in _id
and (_id.startswith("mp-entry:") or _id.startswith("mp-entry-"))
): _return = MpEntry.load_cds_id(_id, client_user_agent, cds, deleted)
else:
vfs_object = Implementation.load_vfs_url(_id, True)
if (vfs_object.is_directory()): entry_class_name = "dNG.data.upnp.resources.MpEntry"
else:
mimetype = vfs_object.get_mimetype()
mimetype_definition = MimeType.get_instance().get(mimetype = mimetype)
mimeclass = (mimetype.split("/", 1)[0] if (mimetype_definition is None) else mimetype_definition['class'])
camel_case_mimeclass = "".join([ word.capitalize() for word in re.split("\\W", mimeclass) ])
entry_class_name = "dNG.data.upnp.resources.MpEntry{0}".format(camel_case_mimeclass)
if (not NamedLoader.is_defined(entry_class_name)): entry_class_name = "dNG.data.upnp.resources.MpEntry"
#
_return = NamedLoader.get_instance(entry_class_name, False)
if (_return is not None and (not _return.init_cds_id(_id, client_user_agent, deleted))): _return = None
#
return _return
def run(self):
"""
Task execution
:since: v0.2.00
"""
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
user_profile = user_profile_class.load_username(self.username)
secid = user_profile_class.generate_secid()
secid_hashed = Tmd5.password_hash(re.sub("\\W+", "", secid), Settings.get("pas_user_profile_password_salt"), self.username)
user_profile.set_data_attributes(secid = secid_hashed)
user_profile.save()
user_profile_data = user_profile.get_data_attributes("name", "lang", "email")
L10n.init("core", user_profile_data['lang'])
L10n.init("pas_core", user_profile_data['lang'])
L10n.init("pas_http_user", user_profile_data['lang'])
l10n = L10n.get_instance(user_profile_data['lang'])
email_renderer = NamedLoader.get_instance("dNG.data.text.user.SecIDUpdatedEMailRenderer", l10n = l10n)
content = email_renderer.render(user_profile_data, secid)
subject = l10n.get("pas_http_user_title_sec_id_updated")
part = Part(Part.TYPE_MESSAGE_BODY, "text/plain", content)
message = Message()
message.add_body(part)
message.set_subject(subject)
message.set_to(Message.format_address(user_profile_data['name'], user_profile_data['email']))
smtp_client = SmtpClient()
smtp_client.set_message(message)
smtp_client.send()
def _get_hook(self):
"""
Returns the task hook to be called.
:return: (mixed) Task hook either as str or an instance of "AbstractHook"
:since: v0.2.00
"""
_return = (NamedLoader.get_instance("dNG.tasks.DatabaseLrtHook", hook = self.hook, **self.params)
if (self.params.get("_lrt_hook", False)) else
self.hook
)
return _return
def load_all(params, last_return = None):
"""
Load and register all SQLAlchemy objects to generate database tables.
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:since: v0.2.00
"""
NamedLoader.get_class("dNG.database.instances.MpUpnpAudioResource")
NamedLoader.get_class("dNG.database.instances.MpUpnpImageResource")
NamedLoader.get_class("dNG.database.instances.MpUpnpResource")
NamedLoader.get_class("dNG.database.instances.MpUpnpVideoResource")
return last_return
def run(self):
"""
Task execution
:since: v0.2.00
"""
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
user_profile = user_profile_class.load_username(self.username)
original_user_profile_data = user_profile.get_data_attributes(*self.values_changed.keys())
user_profile.set_data_attributes(**self.values_changed)
user_profile.save()
DatabaseTasksProxy.get_instance().add("dNG.pas.user.Profile.onEdited.{0}".format(self.username),
"dNG.pas.user.Profile.onEdited",
1,
user_profile_id = user_profile.get_id(),
user_profile_data_changed = self.values_changed,
original_user_profile_data = original_user_profile_data
)
task_data = DatabaseTasks.get_instance().get(self.vid)
if (task_data is not None and "_task" in task_data):
task_data['_task'].set_status_completed()
task_data['_task'].save()
#
user_profile_data = user_profile.get_data_attributes("id", "name", "lang")
L10n.init("core", user_profile_data['lang'])
L10n.init("pas_core", user_profile_data['lang'])
L10n.init("pas_http_user", user_profile_data['lang'])
l10n = L10n.get_instance(user_profile_data['lang'])
_return = PredefinedHttpRequest()
_return.set_module("output")
_return.set_service("http")
_return.set_action("done")
_return.set_parameter_chained("title", l10n.get("pas_http_user_title_change_profile"))
_return.set_parameter_chained("message", l10n.get("pas_http_user_done_change_profile"))
_return.set_parameter_chained("lang", l10n.get_lang())
_return.set_parameter_chained("target_iline", "m=user;s=profile;lang={0};dsd=upid+{1}".format(user_profile_data['lang'], user_profile_data['id']))
return _return
def reload_plugins(prefix = None):
"""
Reload all plugins or the plugins matching the given prefix.
:param prefix: Plugin prefix
:return: (bool) True on success
:since: v0.2.00
"""
# pylint: disable=broad-except, no-member
_return = True
for package in Manager._plugins:
if (prefix is None or package.startswith("{0}.".format(prefix))):
modules = (Manager._plugins[package].copy()
if (hasattr(Manager._plugins[package], "copy")) else
copy(Manager._plugins[package])
)
if (_mode == _MODE_IMPORT_MODULE
and hasattr(importlib, "invalidate_caches")
): importlib.invalidate_caches()
for module_name in modules:
try:
module = NamedLoader._get_module(module_name)
if (module is not None and hasattr(module, "unregister_plugin")): module.unregister_plugin()
try: reload(module)
except Exception: Manager._plugins[package].remove(module_name)
if (module is not None and hasattr(module, "on_plugin_reloaded")): module.on_plugin_reloaded()
except Exception as handled_exception:
if (Manager._log_handler is not None): Manager._log_handler.error(handled_exception, context = "pas_plugins")
_return = False
#
#
package_prefix = (package[:package.rindex(".")] if (prefix is None) else prefix)
package_plugin = package[1 + package.rindex("."):]
Manager.load_plugin(package_plugin, package_prefix)
#
#
return _return
def run(self):
"""
Task execution
:since: v0.2.00
"""
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
user_profile = user_profile_class.load_username(self.username)
user_profile.unlock()
user_profile.save()
database_tasks_proxy = DatabaseTasksProxy.get_instance()
database_tasks_proxy.add("dNG.pas.user.Profile.updateSecID.{0}".format(self.username),
"dNG.pas.user.Profile.updateSecID",
1,
username = self.username
)
database_tasks_proxy.remove("dNG.pas.user.Profile.delete.{0}".format(self.username))
task_data = DatabaseTasks.get_instance().get(self.vid)
if (task_data is not None and "_task" in task_data):
task_data['_task'].set_status_completed()
task_data['_task'].save()
#
user_profile_data = user_profile.get_data_attributes("name", "lang")
L10n.init("core", user_profile_data['lang'])
L10n.init("pas_core", user_profile_data['lang'])
L10n.init("pas_http_user", user_profile_data['lang'])
l10n = L10n.get_instance(user_profile_data['lang'])
_return = PredefinedHttpRequest()
_return.set_module("output")
_return.set_service("http")
_return.set_action("done")
_return.set_parameter_chained("title", l10n.get("pas_http_user_title_registration"))
_return.set_parameter_chained("message", l10n.get("pas_http_user_done_registration"))
_return.set_parameter_chained("lang", l10n.get_lang())
_return.set_parameter_chained("target_iline", "m=user;s=status;a=login;lang={0}".format(user_profile_data['lang']))
return _return
def after_apply_schema(params, last_return = None):
"""
Called for "dNG.pas.Database.applySchema.after"
:param params: Parameter specified
:param last_return: The return value from the last hook called.
:return: (mixed) Return value
:since: v0.2.00
"""
resource_class = NamedLoader.get_class("dNG.database.instances.MpUpnpResource")
Schema.apply_version(resource_class)
audio_class = NamedLoader.get_class("dNG.database.instances.MpUpnpAudioResource")
Schema.apply_version(audio_class)
image_class = NamedLoader.get_class("dNG.database.instances.MpUpnpImageResource")
Schema.apply_version(image_class)
video_class = NamedLoader.get_class("dNG.database.instances.MpUpnpVideoResource")
Schema.apply_version(video_class)
return last_return
def _ensure_administrative_user_account():
"""
Checks if at least one active administrative user profile exists. Creates
one if this is not the case.
:since: v0.2.00
"""
cli = InteractiveCli.get_instance()
cli.output_info("Validating administrative account ...")
user_profile_class = NamedLoader.get_class("dNG.data.user.Profile")
if (next(user_profile_class.load_list(limit = 1, _type = "ad"), None) is not None): cli.output_info("Administrative account is available")
else:
cli.output_info("No valid administrative account found")
Settings.read_file("{0}/settings/pas_user_profile.json".format(Settings.get("path_data")))
password = "".join(choice(string.ascii_lowercase + string.ascii_uppercase + string.digits) for _ in range(20))
password_encrypted = Tmd5.password_hash(password, Settings.get("pas_user_profile_password_salt"), "root")
cli.output("")
cli.output("A new default account will be generated.")
cli.output("")
cli.output("---------------------------------")
cli.output("User name: root")
cli.output(" e-mail: [email protected]")
cli.output(" Password: {0}", password)
cli.output("---------------------------------")
cli.output("")
cli.output("Please change this account as soon as possible.")
cli.output("")
user_profile = user_profile_class()
user_profile.set_data_attributes(type = user_profile_class.get_type_int("ad"),
name = "root",
password = password_encrypted,
locked = False,
email = "*****@*****.**"
)
user_profile.save()
