def __export_folder(self, driveid, folder, export_folder, export,
items_info):
folder_id = Utils.str(folder['id'])
folder_name = Utils.unicode(folder['name'])
folder_path = os.path.join(os.path.join(export_folder, folder_name),
'')
if not xbmcvfs.exists(folder_path):
try:
xbmcvfs.mkdirs(folder_path)
except:
if self._system_monitor.waitForAbort(3):
return
xbmcvfs.mkdirs(folder_path)
items = self.get_provider().get_folder_items(
Utils.default(Utils.get_safe_value(folder, 'drive_id'), driveid),
folder['id'])
if self.cancel_operation():
return
for item in items:
if 'folder' in item:
if self._child_count_supported:
self._exporting_target += int(
item['folder']['child_count'])
else:
self._exporting_target += 1
for item in items:
is_folder = 'folder' in item
item_id = Utils.str(item['id'])
item_name = Utils.unicode(item['name'])
item_name_extension = item['name_extension']
file_path = os.path.join(folder_path, item_name)
if is_folder:
ExportManager.add_item_info(items_info, item_id, item_name,
os.path.join(file_path, ''),
folder_id)
self.__export_folder(driveid, item, folder_path, export,
items_info)
elif (('video' in item
or item_name_extension in self._video_file_extensions)
and export['content_type'] == 'video') or (
'audio' in item and export['content_type'] == 'audio'):
item_name += ExportManager._strm_extension
file_path += ExportManager._strm_extension
ExportManager.create_strm(driveid, item, file_path,
export['content_type'],
self._addon_url)
ExportManager.add_item_info(items_info, item_id, item_name,
file_path, folder_id)
self._exporting_count += 1
p = int(self._exporting_count / float(self._exporting_target) *
100)
if self._exporting_percent < p:
self._exporting_percent = p
self._export_progress_dialog_bg.update(
self._exporting_percent, self._addon_name + ' ' +
self._common_addon.getLocalizedString(32024),
file_path[len(export['destination_folder']):])
def _get_display_name(self, account, drive=None, with_format=False):
s = '[B]%s[/B]' if with_format else '%s'
display = s % Utils.unicode(account['name'])
if drive:
if 'type' in drive and drive['type']:
display += ' | ' + self.get_provider().get_drive_type_name(
drive['type'])
if 'name' in drive and drive['name']:
display += ' | ' + Utils.unicode(drive['name'])
return display
def _run_export(self, driveid, item_id=None):
export_manager = ExportManager(self._account_manager._addon_data_path)
export = export_manager.load()[item_id]
Logger.debug('Running export:')
Logger.debug(export)
if Utils.get_safe_value(export, 'exporting', False):
self._dialog.ok(
self._addon_name,
self._common_addon.getLocalizedString(32059) + ' ' +
self._common_addon.getLocalizedString(32038))
else:
export['exporting'] = True
export_manager.save()
export_folder = export['destination_folder']
if xbmcvfs.exists(export_folder):
self.get_provider().configure(self._account_manager, driveid)
self._export_progress_dialog_bg.create(
self._addon_name + ' ' +
self._common_addon.getLocalizedString(32024),
self._common_addon.getLocalizedString(32025))
self._export_progress_dialog_bg.update(0)
item = self.get_provider().get_item(export['item_driveid'],
item_id)
if self.cancel_operation():
return
if self._child_count_supported:
self._exporting_target = int(item['folder']['child_count'])
self._exporting_target += 1
folder_name = Utils.unicode(item['name'])
folder_path = os.path.join(
os.path.join(export_folder, folder_name), '')
if self._addon.getSetting(
'clean_folder') != 'true' or not xbmcvfs.exists(
folder_path) or self._remove_folder(folder_path):
self._exporting = item_id
export_items_info = {}
ExportManager.add_item_info(export_items_info, item_id,
folder_name, folder_path, None)
self.__export_folder(driveid, item, export_folder, export,
export_items_info)
export_manager.save_items_info(item_id, export_items_info)
if Utils.get_safe_value(export, 'update_library',
False) and self._content_type:
database = self._content_type
if database == 'audio':
database = 'music'
KodiUtils.update_library(database)
else:
error = self._common_addon.getLocalizedString(
32066) % folder_path
Logger.debug(error)
self._dialog.ok(self._addon_name, error)
self._export_progress_dialog_bg.close()
else:
error = self._common_addon.getLocalizedString(
32026) % export_folder
Logger.debug(error)
self._dialog.ok(self._addon_name, error)
export['exporting'] = False
export_manager.save()
def _list_exports(self, driveid):
self._export_manager = ExportManager(self._profile_path)
exports = self._export_manager.get_exports()
listing = []
for exportid in exports:
export = exports[exportid]
if export['driveid'] == driveid and export[
'content_type'] == self._content_type:
item_name = Utils.unicode(export['name'])
params = {
'action': '_open_export',
'content_type': self._content_type,
'driveid': driveid,
'item_driveid': export['item_driveid'],
'item_id': export['id'],
'name': urllib.parse.quote(Utils.str(item_name))
}
url = self._addon_url + '?' + urllib.parse.urlencode(params)
list_item = xbmcgui.ListItem(item_name)
context_options = []
params['action'] = '_run_export'
context_options.append((KodiUtils.localize(21479),
'RunPlugin(' + self._addon_url + '?' +
urllib.parse.urlencode(params) + ')'))
params['action'] = '_remove_export'
context_options.append(
(KodiUtils.localize(1210), 'RunPlugin(' + self._addon_url +
'?' + urllib.parse.urlencode(params) + ')'))
list_item.addContextMenuItems(context_options)
listing.append((url, list_item, True))
xbmcplugin.addDirectoryItems(self._addon_handle, listing, len(listing))
xbmcplugin.endOfDirectory(self._addon_handle, True)
def __init__(self):
profile_path = Utils.unicode(KodiUtils.translate_path(KodiUtils.get_addon_info('profile')))
ini_path = os.path.join(profile_path, 'onedrive.ini')
if os.path.exists(ini_path):
config = ConfigParser()
account_manager = AccountManager(profile_path)
config.read(ini_path)
for driveid in config.sections():
Logger.notice('Migrating drive %s...' % driveid)
account = { 'id' : driveid, 'name' : config.get(driveid, 'name')}
account['drives'] = [{
'id' : driveid,
'name' : '',
'type' : 'migrated'
}]
account['access_tokens'] = {
'access_token': config.get(driveid, 'access_token'),
'refresh_token': config.get(driveid, 'refresh_token'),
'expires_in': 0,
'date': 0
}
try:
account_manager.add_account(account)
except Exception as e:
raise UIException(32021, e)
os.remove(ini_path)
KodiUtils.set_addon_setting('migrated', 'true')
def __init__(self):
profile_path = Utils.unicode(
KodiUtils.translate_path(KodiUtils.get_addon_info('profile')))
ini_path = os.path.join(profile_path, 'onedrive.ini')
if os.path.exists(ini_path):
config = ConfigParser()
account_manager = AccountManager(profile_path)
config.read(ini_path)
for driveid in config.sections():
Logger.notice('Migrating drive %s...' % driveid)
account = {'id': driveid, 'name': config.get(driveid, 'name')}
account['drives'] = [{
'id': driveid,
'name': '',
'type': 'migrated'
}]
account['access_tokens'] = {
'access_token': config.get(driveid, 'access_token'),
'refresh_token': config.get(driveid, 'refresh_token'),
'expires_in': 0,
'date': 0
}
try:
account_manager.add_account(account)
except Exception as e:
raise UIException(32021, e)
os.remove(ini_path)
KodiUtils.set_addon_setting('migrated', 'true')
def _list_drive(self, driveid):
drive_folders = self.get_custom_drive_folders(driveid)
if self.cancel_operation():
return
if drive_folders:
listing = []
url = self._addon_url + '?' + urllib.urlencode({'action':'_list_folder', 'path': '/', 'content_type': self._content_type, 'driveid': driveid})
listing.append((url, xbmcgui.ListItem('[B]%s[/B]' % self.get_my_files_menu_name()), True))
for folder in drive_folders:
params = {'action':'_list_folder', 'path': folder['path'], 'content_type': self._content_type, 'driveid': driveid}
if 'params' in folder:
params.update(folder['params'])
url = self._addon_url + '?' + urllib.urlencode(params)
list_item = xbmcgui.ListItem(Utils.unicode(folder['name']))
if 'context_options' in folder:
list_item.addContextMenuItems(folder['context_options'])
listing.append((url, list_item, True))
if self._content_type == 'video' or self._content_type == 'audio':
url = self._addon_url + '?' + urllib.urlencode({'action':'_list_exports', 'content_type': self._content_type, 'driveid': driveid})
listing.append((url, xbmcgui.ListItem(self._common_addon.getLocalizedString(32000)), True))
xbmcplugin.addDirectoryItems(self._addon_handle, listing, len(listing))
xbmcplugin.endOfDirectory(self._addon_handle, True)
else:
self._list_folder(driveid, path='/')
def play(self, driveid, item_driveid=None, item_id=None):
find_subtitles = self._addon.getSetting(
'set_subtitle') == 'true' and self._content_type == 'video'
item = self.get_item(driveid,
item_driveid,
item_id,
find_subtitles=find_subtitles)
file_name = Utils.unicode(item['name'])
list_item = xbmcgui.ListItem(file_name)
if 'audio' in item:
list_item.setInfo('music', item['audio'])
elif 'video' in item:
list_item.addStreamInfo('video', item['video'])
list_item.select(True)
list_item.setPath(
DownloadServiceUtil.build_download_url(
self._addonid, driveid, item_driveid, item_id,
urllib.quote(Utils.str(file_name))))
list_item.setProperty('mimetype',
Utils.get_safe_value(item, 'mimetype'))
if find_subtitles and 'subtitles' in item:
subtitles = []
for subtitle in item['subtitles']:
subtitles.append(
DownloadServiceUtil.build_download_url(
self._addonid, driveid,
Utils.default(
Utils.get_safe_value(subtitle, 'drive_id'),
driveid), subtitle['id'],
urllib.quote(Utils.str(subtitle['name']))))
list_item.setSubtitles(subtitles)
xbmcplugin.setResolvedUrl(self._addon_handle, True, list_item)
def run_export(self, export):
exporting = Utils.get_safe_value(export, 'exporting', False)
Logger.debug('Run export requested. Exporting = %s' % (exporting, ))
if not exporting:
export['exporting'] = True
export['origin'] = 'schedule'
self.export_manager.save_export(export)
try:
self._export_progress_dialog_bg.create(
self._addon_name + ' ' +
self._common_addon.getLocalizedString(32024),
self._common_addon.getLocalizedString(32025))
export_folder = export['destination_folder']
if not KodiUtils.file_exists(export_folder):
Logger.debug('creating folder: %s' % (export_folder, ))
if not KodiUtils.mkdirs(export_folder):
Logger.debug('unable to create folder %s' %
(export_folder, ))
if KodiUtils.file_exists(export_folder):
driveid = export['driveid']
self.provider.configure(self._account_manager, driveid)
exportid = export['id']
items_info = {}
ExportManager.add_item_info(items_info, 'root-folder',
None, export_folder, None,
'folder')
self.export_manager.save_items_info(exportid, items_info)
item = self.provider.get_item(export['item_driveid'],
exportid)
item.update({
'parent': 'root-folder',
'origin': 'schedule'
})
self.export_manager.save_pending_changes(
exportid, deque([item]))
self.export_manager.save_retry_changes(exportid, deque([]))
self.process_pending_changes(
exportid,
on_before_change=self._show_progress_before_change)
if Utils.get_safe_value(export, 'update_library', False):
if Utils.get_safe_value(export, 'content_type',
'') == 'audio':
KodiUtils.update_library('music')
else:
KodiUtils.update_library('video')
except Exception as e:
ErrorReport.handle_exception(e)
KodiUtils.show_notification(
self._common_addon.getLocalizedString(32027) + ' ' +
Utils.unicode(e))
finally:
export['exporting'] = False
del export['origin']
self.export_manager.save_export(export)
self._export_progress_dialog_bg.close()
else:
KodiUtils.show_notification(
self._common_addon.getLocalizedString(32059) + ' ' +
self._common_addon.getLocalizedString(32038))
def show_notification(msg, time=5000):
import xbmcgui
from clouddrive.common.utils import Utils
xbmcgui.Dialog().notification(
KodiUtils.get_addon_info('name'), msg,
Utils.unicode(KodiUtils.get_addon_info('path') + '/icon.png'),
time)
class DownloadService(BaseServerService):
name = 'download'
profile_path = Utils.unicode(KodiUtils.translate_path(KodiUtils.get_addon_info('profile')))
def __init__(self, provider_class):
super(DownloadService, self).__init__(provider_class)
self._handler = Download
def _remove_export(self, driveid, item_id):
self._export_manager = ExportManager(self._profile_path)
item = self._export_manager.get_exports()[item_id]
remove_export = self._dialog.yesno(
self._addon_name,
self._common_addon.getLocalizedString(32001) %
Utils.unicode(item['name']))
if remove_export:
keep_locals = self._dialog.yesno(
self._addon_name,
self._common_addon.getLocalizedString(32086) %
Utils.unicode(item['name']))
if not keep_locals:
self._export_manager.remove_export(item_id, False)
else:
self._export_manager.remove_export(item_id)
KodiUtils.executebuiltin('Container.Refresh')
def _remove_export(self, driveid, item_id):
export_manager = ExportManager(self._account_manager._addon_data_path)
item = export_manager.load()[item_id]
if self._dialog.yesno(
self._addon_name,
self._common_addon.getLocalizedString(32001) %
Utils.unicode(item['name']), None):
export_manager.remove_export(item_id)
KodiUtils.executebuiltin('Container.Refresh')
def onInit(self):
import pyqrcode
self._image_path = os.path.join(Utils.unicode(KodiUtils.translate_path(KodiUtils.get_addon_info("profile", "script.module.clouddrive.common"))),"qr.png")
qrcode = pyqrcode.create(self.qr_code)
qrcode.png(self._image_path, scale=10)
del qrcode
self.getControl(self._heading_control).setLabel(self.heading)
self.getControl(self._qr_control).setImage(self._image_path)
self.update(self.percent, self.line1, self.line2, self.line3)
def remove_export(self, exportid, keep_local=True):
export = self.exports_db.get(exportid)
self.exports_db.remove(exportid)
self.export_items_db.remove(exportid)
self.export_items_db.remove('pending-' + exportid)
self.export_items_db.remove('retry-' + exportid)
path = os.path.join(export['destination_folder'], Utils.unicode(export['name']), '')
if not keep_local:
if KodiUtils.file_exists(path):
Utils.remove_folder(path)
def play(self, driveid, item_driveid=None, item_id=None):
self.get_provider().configure(self._account_manager, driveid)
find_subtitles = self._addon.getSetting('set_subtitle') == 'true' and self._content_type == 'video'
item = self.get_provider().get_item(item_driveid, item_id, find_subtitles=find_subtitles)
file_name = Utils.unicode(item['name'])
list_item = xbmcgui.ListItem(file_name)
succeeded = True
info = KodiUtils.get_current_library_info()
if not info:
info = KodiUtils.find_exported_video_in_library(item_id, file_name + ExportManager._strm_extension)
if info and info['id']:
Logger.debug('library info: %s' % Utils.str(info))
KodiUtils.set_home_property('dbid', Utils.str(info['id']))
KodiUtils.set_home_property('dbtype', info['type'])
KodiUtils.set_home_property('addonid', self._addonid)
details = KodiUtils.get_video_details(info['type'], info['id'])
Logger.debug('library details: %s' % Utils.str(details))
if details and 'resume' in details:
KodiUtils.set_home_property('playcount', Utils.str(details['playcount']))
resume = details['resume']
if resume['position'] > 0:
play_resume = False
if self.iskrypton:
play_resume = KodiUtils.get_addon_setting('resume_playing') == 'true'
elif KodiUtils.get_addon_setting('ask_resume') == 'true':
d = datetime(1,1,1) + timedelta(seconds=resume['position'])
t = '%02d:%02d:%02d' % (d.hour, d.minute, d.second)
Logger.debug(t)
option = self._dialog.contextmenu([KodiUtils.localize(32054, addon=self._common_addon) % t, KodiUtils.localize(12021)])
Logger.debug('selected option: %d' % option)
if option == -1:
succeeded = False
elif option == 0:
play_resume = True
if play_resume:
list_item.setProperty('resumetime', Utils.str(resume['position']))
list_item.setProperty('startoffset', Utils.str(resume['position']))
list_item.setProperty('totaltime', Utils.str(resume['total']))
else:
from clouddrive.common.service.player import KodiPlayer
KodiPlayer.cleanup()
if 'audio' in item:
list_item.setInfo('music', item['audio'])
elif 'video' in item:
list_item.addStreamInfo('video', item['video'])
list_item.select(True)
list_item.setPath(self._get_item_play_url(file_name, driveid, item_driveid, item_id))
list_item.setProperty('mimetype', Utils.get_safe_value(item, 'mimetype'))
if find_subtitles and 'subtitles' in item:
subtitles = []
for subtitle in item['subtitles']:
subtitles.append(self._get_item_play_url(urllib.quote(Utils.str(subtitle['name'])), driveid, Utils.default(Utils.get_safe_value(subtitle, 'drive_id'), driveid), subtitle['id'], True))
list_item.setSubtitles(subtitles)
if not self.cancel_operation():
xbmcplugin.setResolvedUrl(self._addon_handle, succeeded, list_item)
def handle_exception(ex):
stacktrace = ExceptionUtils.full_stacktrace(ex)
rex = ExceptionUtils.extract_exception(ex, RequestException)
httpex = ExceptionUtils.extract_exception(ex, HTTPError)
dnf = ExceptionUtils.extract_exception(ex, DriveNotFoundException)
line1 = ''
line2 = Utils.unicode(ex)
send_report = True
log_report = True
if rex and rex.response:
line1 = Utils.unicode(rex)
line2 = ExceptionUtils.extract_error_message(rex.response)
if httpex:
if httpex.code == 401:
send_report = False
elif httpex.code == 404:
send_report = False
log_report = False
if dnf:
send_report = False
log_report = False
addonid = KodiUtils.get_addon_info('id')
addon_version = KodiUtils.get_addon_info('version')
common_addon_version = KodiUtils.get_addon_info(
'version', 'script.module.clouddrive.common')
report = '[%s] [%s]/[%s]\n\n%s\n%s\n%s\n\n%s' % (
addonid, addon_version, common_addon_version, line1, line2, '',
stacktrace)
if rex:
report += '\n\n%s\nResponse:\n%s' % (rex.request, rex.response)
if log_report:
Logger.debug(report)
else:
Logger.debug(ex)
if send_report:
Logger.notice(report)
Logger.notice('Report sent')
ErrorReport.send_report(report)
def __init__(self, provider_class):
self.abort = False
self._system_monitor = KodiUtils.get_system_monitor()
self.provider = provider_class()
self.addonid = KodiUtils.get_addon_info('id')
self._profile_path = Utils.unicode(KodiUtils.translate_path(KodiUtils.get_addon_info('profile')))
self._startup_type = Utils.str(ExportScheduleDialog._startup_type)
self.export_manager = ExportManager(self._profile_path)
self._account_manager = AccountManager(self._profile_path)
self._video_file_extensions = KodiUtils.get_supported_media("video")
self._audio_file_extensions = KodiUtils.get_supported_media("music")
def process_change_move(self, change, items_info):
change_type = 'move'
parent_id = Utils.get_safe_value(change, 'parent', '')
parent_item_info = items_info[parent_id]
parent_item_path = parent_item_info['full_local_path']
changed_item_id = change['id']
changed_item_name = Utils.get_safe_value(change, 'name', '')
changed_item_extension = Utils.get_safe_value(change, 'name_extension',
'')
changed_item_mimetype = Utils.get_safe_value(change, 'mimetype', '')
item_info = items_info[changed_item_id]
item_type = item_info['type']
is_folder = item_type == 'folder'
item_info_path = item_info['full_local_path']
new_path = os.path.join(Utils.unicode(parent_item_path),
Utils.unicode(changed_item_name))
if is_folder:
change_type += '_folder'
new_path = os.path.join(new_path, '')
else:
change_type += '_file'
if changed_item_extension in self._video_file_extensions or 'video' in changed_item_mimetype or 'video' in change:
new_path += '.strm'
Logger.debug('%s from: %s to: %s' % (
change_type,
item_info_path,
new_path,
))
if KodiUtils.file_exists(new_path):
Logger.debug('location already exists: %s. removing...' %
(new_path, ))
if is_folder:
Utils.remove_folder(item_info_path, self._system_monitor)
else:
KodiUtils.file_delete(item_info_path)
if not KodiUtils.file_rename(item_info_path, new_path):
change_type += '_retry'
ExportManager.add_item_info(items_info, changed_item_id,
Utils.unicode(changed_item_name), new_path,
parent_id, item_type)
return change_type
def __init__(self):
self._addon = xbmcaddon.Addon()
self._addonid = self._addon.getAddonInfo('id')
self._addon_name = self._addon.getAddonInfo('name')
self._addon_url = sys.argv[0]
self._addon_version = self._addon.getAddonInfo('version')
self._common_addon_id = 'script.module.clouddrive.common'
self._common_addon = xbmcaddon.Addon(self._common_addon_id)
self._common_addon_version = self._common_addon.getAddonInfo('version')
self._dialog = xbmcgui.Dialog()
self._profile_path = Utils.unicode(
xbmc.translatePath(self._addon.getAddonInfo('profile')))
self._progress_dialog = DialogProgress(self._addon_name)
self._progress_dialog_bg = DialogProgressBG(self._addon_name)
self._export_progress_dialog_bg = DialogProgressBG(self._addon_name)
self._system_monitor = xbmc.Monitor()
self._account_manager = AccountManager(self._profile_path)
self._home_window = xbmcgui.Window(10000)
if len(sys.argv) > 1:
self._addon_handle = int(sys.argv[1])
self._addon_params = urlparse.parse_qs(sys.argv[2][1:])
for param in self._addon_params:
self._addon_params[param] = self._addon_params.get(param)[0]
self._content_type = Utils.get_safe_value(self._addon_params,
'content_type')
if not self._content_type:
wid = xbmcgui.getCurrentWindowId()
if wid == 10005 or wid == 10500 or wid == 10501 or wid == 10502:
self._content_type = 'audio'
elif wid == 10002:
self._content_type = 'image'
else:
self._content_type = 'video'
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_NONE)
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_UNSORTED)
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_LABEL)
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_FILE)
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_SIZE)
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_DATE)
xbmcplugin.addSortMethod(handle=self._addon_handle,
sortMethod=xbmcplugin.SORT_METHOD_DURATION)
def __init__(self):
self._addon = KodiUtils.get_addon()
self._addonid = self._addon.getAddonInfo('id')
self._addon_name = self._addon.getAddonInfo('name')
self._addon_url = sys.argv[0]
self._addon_version = self._addon.getAddonInfo('version')
self._common_addon_id = 'script.module.clouddrive.common'
self._common_addon = KodiUtils.get_addon(self._common_addon_id)
self._common_addon_version = self._common_addon.getAddonInfo('version')
self._dialog = xbmcgui.Dialog()
self._profile_path = Utils.unicode(KodiUtils.translate_path(self._addon.getAddonInfo('profile')))
self._progress_dialog = DialogProgress(self._addon_name)
self._progress_dialog_bg = DialogProgressBG(self._addon_name)
self._system_monitor = KodiUtils.get_system_monitor()
self._account_manager = AccountManager(self._profile_path)
self._pin_dialog = None
self.provider = GoogleDrive()
class SourceService(BaseServerService):
name = 'source'
profile_path = Utils.unicode(KodiUtils.translate_path(KodiUtils.get_addon_info('profile')))
def __init__(self, provider_class, handler=Source):
super(SourceService, self).__init__(provider_class)
self._handler = handler
addonid = KodiUtils.get_addon_info('id')
Cache(addonid, 'page', 0).clear()
Cache(addonid, 'children', 0).clear()
Cache(addonid, 'items', 0).clear()
def get_port(self):
return int(KodiUtils.get_addon_setting('port_directory_listing'))
def start(self):
if KodiUtils.get_addon_setting('allow_directory_listing') == 'true':
super(SourceService, self).start()
def __init__(self, provider_class):
self.abort = False
self._system_monitor = KodiUtils.get_system_monitor()
self.provider = provider_class()
self.addonid = KodiUtils.get_addon_info('id')
self._addon_name = KodiUtils.get_addon_info('name')
self._common_addon_id = 'script.module.clouddrive.common'
self._common_addon = KodiUtils.get_addon(self._common_addon_id)
self._profile_path = Utils.unicode(
KodiUtils.translate_path(KodiUtils.get_addon_info('profile')))
self._startup_type = Utils.str(ExportScheduleDialog._startup_type)
self.export_manager = ExportManager(self._profile_path)
self._account_manager = AccountManager(self._profile_path)
self._video_file_extensions = [
x for x in KodiUtils.get_supported_media("video")
if x not in ('', 'zip')
]
self._audio_file_extensions = KodiUtils.get_supported_media("music")
self._artwork_file_extensions = [
'back', 'banner', 'characterart', 'clearart', 'clearlogo',
'discart', 'fanart', 'keyart', 'landscape', 'poster', 'spine',
'thumb', 'folder', 'cover', 'animatedposter', 'animatedfanart'
]
self._export_progress_dialog_bg = DialogProgressBG(self._addon_name)
def download(self, driveid, item_driveid=None, item_id=None):
dest_folder = self._dialog.browse(
0, self._common_addon.getLocalizedString(32002), 'files')
if dest_folder:
provider = self.get_provider()
provider.configure(self._account_manager, driveid)
item = provider.get_item(item_driveid,
item_id,
include_download_info=True)
name = Utils.get_safe_value(item, 'name', item['id'])
download_path = os.path.join(dest_folder, Utils.unicode(name))
download_size = Utils.get_safe_value(item, 'size', 0)
on_update_download = lambda request: self._progress_dialog_bg.update(
int(1.0 * request.download_progress / download_size * 100),
self._addon_name,
self._common_addon.getLocalizedString(32056) % name)
if ExportManager.download(item,
download_path,
provider,
on_update_download=on_update_download):
msg = self._common_addon.getLocalizedString(32057) % name
else:
msg = self._common_addon.getLocalizedString(32087) % name
KodiUtils.show_notification(msg)
def process_change_create(self, change, items_info, export):
content_type = export['content_type']
changed_item_id = change['id']
changed_item_name = Utils.get_safe_value(change, 'name', '')
changed_item_extension = Utils.get_safe_value(change, 'name_extension',
'')
parent_id = Utils.get_safe_value(change, 'parent', '')
is_folder = 'folder' in change
item_type = 'folder' if is_folder else 'file'
parent_item_info = Utils.get_safe_value(items_info, parent_id)
if parent_item_info:
parent_item_path = parent_item_info['full_local_path']
new_path = os.path.join(Utils.unicode(parent_item_path),
Utils.unicode(changed_item_name))
change_type = 'create'
if is_folder:
change_type += '_folder'
new_path = os.path.join(new_path, '')
if parent_id == 'root-folder' and KodiUtils.get_addon_setting(
'clean_folder') == 'true' and KodiUtils.file_exists(
new_path):
if not Utils.remove_folder(new_path):
error = self._common_addon.getLocalizedString(
32066) % new_path
KodiUtils.show_notification(error)
Logger.debug(error)
if not KodiUtils.file_exists(new_path):
Logger.debug('creating folder: %s' % (new_path, ))
if not KodiUtils.mkdir(new_path):
change_type += '_retry'
Logger.debug('unable to create folder %s' %
(new_path, ))
else:
change_type += '_ignored'
Logger.debug('folder %s already exists' % (new_path, ))
else:
download_artwork = 'download_artwork' in export and export[
'download_artwork']
is_download = changed_item_extension \
and (
changed_item_extension in ['strm', 'nomedia']
or (
download_artwork
and (
changed_item_extension in ['nfo']
or (
changed_item_extension in ['jpg', 'png']
and (
any(s in changed_item_name for s in self._artwork_file_extensions)
or parent_item_info['name'] in ['.actors', 'extrafanart']
)
)
)
)
)
if is_download:
Logger.debug('downloading file: %s' % (new_path, ))
change_type = 'download_file'
cloud_size = Utils.get_safe_value(change, 'size', 0)
local_size = KodiUtils.file(new_path).size()
if cloud_size != local_size:
Logger.debug(
'Download requested. File changed: Local file size (%s) - cloud file size (%s)'
% (
Utils.str(local_size),
Utils.str(cloud_size),
))
if not ExportManager.download(change, new_path,
self.provider):
change_type += "_retry"
Logger.debug('Unable to download file: %s' %
(new_path, ))
else:
change_type += '_ignored'
Logger.debug(
'Download ignored: Local file size (%s) is equal to cloud file size (%s)'
% (
Utils.str(local_size),
Utils.str(cloud_size),
))
else:
is_stream_file = (('video' in change or (changed_item_extension and changed_item_extension in self._video_file_extensions)) and content_type == 'video') \
or (('audio' in change or (changed_item_extension and changed_item_extension in self._audio_file_extensions)) and content_type == 'audio')
if is_stream_file:
change_type += '_file'
if KodiUtils.get_addon_setting(
'no_extension_strm') == 'true':
new_path = Utils.remove_extension(new_path)
new_path += ExportManager._strm_extension
strm_content = ExportManager.get_strm_link(
export['driveid'], change, content_type,
'plugin://%s/' % self.addonid)
Logger.debug('creating strm file: %s' % (new_path, ))
if not KodiUtils.file_exists(
new_path) or KodiUtils.file(
new_path).size() != len(strm_content):
if not ExportManager.create_text_file(
new_path, strm_content):
change_type += '_retry'
else:
change_type += '_ignored'
Logger.debug(
'ignoring strm creation: %s, strm file already exists. same expected size.'
% (new_path, ))
else:
change_type = None
Logger.debug('ignoring file: %s' % (new_path, ))
if change_type:
ExportManager.add_item_info(items_info, changed_item_id,
Utils.unicode(changed_item_name),
new_path, parent_id, item_type)
else:
Logger.debug('invalid state. no parent info found')
change_type = None
return change_type
def process_pending_changes(self,
exportid,
on_after_change=None,
on_before_change=None):
changes_done = []
pending_changes = self.export_manager.get_pending_changes(exportid)
if pending_changes:
export = self.export_manager.get_exports()[exportid]
Logger.debug('*** Processing all changes for export id: %s' %
exportid)
try:
Logger.debug(' Exporting "%s" in %s' %
(Utils.unicode(export['name']),
Utils.unicode(export['destination_folder'])))
except Exception:
Logger.debug(' Export name: %s' % Utils.str(export['name']))
Logger.debug(' Export destination_folder: %s' %
Utils.str(export['destination_folder']))
items_info = Utils.default(
self.export_manager.get_items_info(exportid), {})
retry_changes = []
processed_changes = set()
ignored = 0
while len(pending_changes) > 0:
change = pending_changes.popleft()
change_id = change['id']
if change_id in processed_changes:
continue
processed_changes.add(change_id)
if on_before_change:
on_before_change(change, pending_changes, changes_done,
retry_changes, ignored, export)
change_type = self.process_change(change, items_info, export)
self.export_manager.save_items_info(exportid, items_info)
self.export_manager.save_pending_changes(
exportid, pending_changes)
is_retry = False
if change_type:
if change_type[-6:] == "_retry":
is_retry = True
retry_changes.append(change)
Logger.debug('change marked for retry')
else:
changes_done.append(change)
if change_type == 'create_folder' or (
change_type == 'create_folder_ignored'
and Utils.get_safe_value(change, 'origin',
'') == 'schedule'):
before_add_item = lambda item: self.on_before_add_item(
change, item)
pending_changes.extendleft(
self.get_folder_changes(
export['driveid'], change,
before_add_item))
self.export_manager.save_pending_changes(
exportid, pending_changes)
else:
ignored += 1
if on_after_change:
on_after_change(change, change_type, pending_changes,
changes_done, retry_changes, ignored,
export)
if is_retry:
self.export_manager.save_retry_changes(
exportid, deque(retry_changes))
return changes_done
def _get_progress_header(self, export):
sid = 32024
if Utils.get_safe_value(export, 'origin', '') == 'watch':
sid = 32088
return self._common_addon.getLocalizedString(
sid) + ': ' + Utils.unicode(export['name'])
def _process_items(self, items, driveid):
listing = []
for item in items:
item_id = item['id']
item_name = Utils.unicode(item['name'])
item_name_extension = item['name_extension']
item_driveid = Utils.default(Utils.get_safe_value(item, 'drive_id'), driveid)
list_item = xbmcgui.ListItem(item_name)
url = None
is_folder = 'folder' in item
params = {'content_type': self._content_type, 'item_driveid': item_driveid, 'item_id': item_id, 'driveid': driveid}
if 'extra_params' in item:
params.update(item['extra_params'])
context_options = []
info = {'size': item['size'], 'date': KodiUtils.to_kodi_item_date_str(KodiUtils.to_datetime(Utils.get_safe_value(item, 'last_modified_date')))}
if is_folder:
params['action'] = '_list_folder'
url = self._addon_url + '?' + urllib.urlencode(params)
params['action'] = '_search'
cmd = 'ActivateWindow(%d,%s?%s)' % (xbmcgui.getCurrentWindowId(), self._addon_url, urllib.urlencode(params))
context_options.append((self._common_addon.getLocalizedString(32039), cmd))
if self._content_type == 'audio' or self._content_type == 'video':
params['action'] = '_open_export'
params['name'] = urllib.quote(Utils.str(item_name))
context_options.append((self._common_addon.getLocalizedString(32004), 'RunPlugin('+self._addon_url + '?' + urllib.urlencode(params)+')'))
del params['name']
elif self._content_type == 'image' and self._auto_refreshed_slideshow_supported:
params['action'] = '_slideshow'
context_options.append((self._common_addon.getLocalizedString(32032), 'RunPlugin('+self._addon_url + '?' + urllib.urlencode(params)+')'))
elif (('video' in item or item_name_extension in self._video_file_extensions) and self._content_type == 'video') or (('audio' in item or item_name_extension in self._audio_file_extensions) and self._content_type == 'audio'):
list_item.setProperty('IsPlayable', 'true')
params['action'] = 'play'
url = self._addon_url + '?' + urllib.urlencode(params)
info_type = self._content_type
if 'audio' in item:
info.update(item['audio'])
info_type = 'music'
elif 'video' in item:
list_item.addStreamInfo('video', item['video'])
list_item.setInfo(info_type, info)
if 'thumbnail' in item:
list_item.setArt({'icon': item['thumbnail'], 'thumb': item['thumbnail']})
elif ('image' in item or item_name_extension in self._image_file_extensions) and self._content_type == 'image' and item_name_extension != 'mp4':
if 'url' in item:
url = item['url']
else:
url = self._get_item_play_url(urllib.quote(Utils.str(item_name)), driveid, item_driveid, item_id)
if 'image' in item:
info.update(item['image'])
list_item.setInfo('pictures', info)
if 'thumbnail' in item and item['thumbnail']:
list_item.setArt({'icon': item['thumbnail'], 'thumb': item['thumbnail']})
if url:
context_options.extend(self.get_context_options(list_item, params, is_folder))
list_item.addContextMenuItems(context_options)
mimetype = Utils.default(Utils.get_mimetype_by_extension(item_name_extension), Utils.get_safe_value(item, 'mimetype'))
if mimetype:
list_item.setProperty('mimetype', mimetype)
listing.append((url, list_item, is_folder))
xbmcplugin.addDirectoryItems(self._addon_handle, listing, len(listing))
xbmcplugin.endOfDirectory(self._addon_handle, True)
def process_watch(self):
exports = self.export_manager.get_exports()
update_library = {}
changes_by_drive = {}
for exportid in exports:
export = exports[exportid]
watch = Utils.get_safe_value(export, 'watch', False)
exporting = Utils.get_safe_value(export, 'exporting', False)
retry_changes = self.export_manager.get_retry_changes(exportid)
if (watch or len(retry_changes) > 0) and not exporting:
items_info = self.export_manager.get_items_info(exportid)
if items_info:
export['exporting'] = True
export['origin'] = 'watch'
self.export_manager.save_export(export)
try:
driveid = export['driveid']
if driveid in changes_by_drive:
changes = changes_by_drive[driveid]
else:
self.provider.configure(self._account_manager,
export['driveid'])
changes = self.provider.changes()
changes_by_drive[driveid] = []
changes_by_drive[driveid].extend(changes)
pending_changes = self.export_manager.get_pending_changes(
exportid)
pending_changes.extend(retry_changes)
pending_changes.extend(changes)
if len(changes) > 0 or len(retry_changes) > 0:
self.export_manager.save_pending_changes(
exportid, pending_changes)
if len(retry_changes) > 0:
self.export_manager.save_retry_changes(
exportid, deque([]))
show_export_progress = KodiUtils.get_addon_setting(
'hide_export_progress') != 'true'
if pending_changes and show_export_progress:
self._export_progress_dialog_bg.update(
0, self._addon_name + ' ' +
self._common_addon.getLocalizedString(32088),
self._common_addon.getLocalizedString(32025))
if show_export_progress:
progress_listener = self._show_progress_after_change
else:
progress_listener = None
changes_done = self.process_pending_changes(
exportid, on_after_change=progress_listener)
if changes_done:
if Utils.get_safe_value(export, 'update_library',
False):
update_library[Utils.get_safe_value(
export, 'content_type', 'None')] = True
for change in changes_done:
if change in changes_by_drive[driveid]:
changes_by_drive[driveid].remove(change)
except Exception as e:
ErrorReport.handle_exception(e)
KodiUtils.show_notification(
self._common_addon.getLocalizedString(32027) +
' ' + Utils.unicode(e))
finally:
export['exporting'] = False
del export['origin']
self.export_manager.save_export(export)
else:
self.run_export(export)
self._export_progress_dialog_bg.close()
if update_library:
if Utils.get_safe_value(update_library, 'video', False):
KodiUtils.update_library('video')
if Utils.get_safe_value(update_library, 'audio', False):
KodiUtils.update_library('music')
def _handle_exception(self, ex, show_error_dialog = True):
stacktrace = ExceptionUtils.full_stacktrace(ex)
rex = ExceptionUtils.extract_exception(ex, RequestException)
uiex = ExceptionUtils.extract_exception(ex, UIException)
httpex = ExceptionUtils.extract_exception(ex, HTTPError)
urlex = ExceptionUtils.extract_exception(ex, URLError)
line1 = self._common_addon.getLocalizedString(32027)
line2 = Utils.unicode(ex)
line3 = self._common_addon.getLocalizedString(32016)
if uiex:
line1 = self._common_addon.getLocalizedString(int(Utils.str(uiex)))
line2 = Utils.unicode(uiex.root_exception)
elif rex and rex.response:
line1 += ' ' + Utils.unicode(rex)
line2 = ExceptionUtils.extract_error_message(rex.response)
send_report = True
add_account_cmd = 'RunPlugin('+self._addon_url + '?' + urllib.urlencode({'action':'_add_account', 'content_type': self._content_type})+')'
if isinstance(ex, AccountNotFoundException) or isinstance(ex, DriveNotFoundException):
show_error_dialog = False
if self._dialog.yesno(self._addon_name, self._common_addon.getLocalizedString(32063) % '\n'):
KodiUtils.executebuiltin(add_account_cmd)
elif rex and httpex:
if httpex.code >= 500:
line1 = self._common_addon.getLocalizedString(32035)
line2 = None
line3 = self._common_addon.getLocalizedString(32038)
elif httpex.code >= 400:
driveid = Utils.get_safe_value(self._addon_params, 'driveid')
if driveid:
self._account_manager.load()
account = self._account_manager.get_account_by_driveid(driveid)
drive = self._account_manager.get_drive_by_driveid(driveid)
if KodiUtils.get_signin_server() in rex.request or httpex.code == 401:
send_report = False
show_error_dialog = False
if self._dialog.yesno(self._addon_name, self._common_addon.getLocalizedString(32046) % (self._get_display_name(account, drive, True), '\n')):
KodiUtils.executebuiltin(add_account_cmd)
elif httpex.code == 403:
line1 = self._common_addon.getLocalizedString(32019)
line2 = line3 = None
elif httpex.code == 404:
send_report = False
line1 = self._common_addon.getLocalizedString(32037)
line2 = line2 = None
else:
line1 = self._common_addon.getLocalizedString(32036)
line3 = self._common_addon.getLocalizedString(32038)
else:
if KodiUtils.get_signin_server()+'/pin/' in rex.request and httpex.code == 404 and self._ip_before_pin:
ip_after_pin = Request(KodiUtils.get_signin_server() + '/ip', None).request()
if self._ip_before_pin != ip_after_pin:
send_report = False
line1 = self._common_addon.getLocalizedString(32072)
line2 = self._common_addon.getLocalizedString(32073) % (self._ip_before_pin, ip_after_pin,)
elif urlex:
reason = Utils.str(urlex.reason)
line3 = self._common_addon.getLocalizedString(32074)
if '[Errno 101]' in reason:
line1 = self._common_addon.getLocalizedString(32076)
elif '[Errno 11001]' in reason:
line1 = self._common_addon.getLocalizedString(32077)
elif 'CERTIFICATE_VERIFY_FAILED' in reason:
line1 = self._common_addon.getLocalizedString(32078)
else:
line1 = self._common_addon.getLocalizedString(32075)
report = '[%s] [%s]/[%s]\n\n%s\n%s\n%s\n\n%s' % (self._addonid, self._addon_version, self._common_addon_version, line1, line2, line3, stacktrace)
if rex:
report += '\n\n%s\nResponse:\n%s' % (rex.request, rex.response)
report += '\n\nshow_error_dialog: %s' % show_error_dialog
Logger.error(report)
if show_error_dialog:
self._dialog.ok(self._addon_name, line1, line2, line3)
if send_report:
report_error = KodiUtils.get_addon_setting('report_error', self._common_addon_id) == 'true'
report_error_invite = KodiUtils.get_addon_setting('report_error_invite', self._common_addon_id) == 'true'
if not report_error and not report_error_invite:
if not self._dialog.yesno(self._addon_name, self._common_addon.getLocalizedString(32050), None, None, self._common_addon.getLocalizedString(32012), self._common_addon.getLocalizedString(32013)):
KodiUtils.set_addon_setting('report_error', 'true', self._common_addon_id)
KodiUtils.set_addon_setting('report_error_invite', 'true', self._common_addon_id)
ErrorReport.send_report(report)
def _add_account(self):
request_params = {
'waiting_retry':
lambda request, remaining: self._progress_dialog_bg.
update(int((request.current_delay - remaining) / request.
current_delay * 100),
heading=self._common_addon.getLocalizedString(32043) %
('' if request.current_tries == 1 else ' again'),
message=self._common_addon.getLocalizedString(32044) % str(
int(remaining)
) + ' ' + self._common_addon.getLocalizedString(32045) %
(str(request.current_tries + 1), str(request.tries))),
'on_complete':
lambda request:
(self._progress_dialog.close(), self._progress_dialog_bg.close()),
'cancel_operation':
self.cancel_operation,
'wait':
self._system_monitor.waitForAbort
}
provider = self.get_provider()
self._progress_dialog.update(
0, self._common_addon.getLocalizedString(32008))
self._ip_before_pin = Request(KodiUtils.get_signin_server() + '/ip',
None).request()
pin_info = provider.create_pin(request_params)
self._progress_dialog.close()
if self.cancel_operation():
return
if not pin_info:
raise Exception('Unable to retrieve a pin code')
tokens_info = {}
request_params[
'on_complete'] = lambda request: self._progress_dialog_bg.close()
self._pin_dialog = QRDialogProgress.create(
self._addon_name,
KodiUtils.get_signin_server() + '/signin/%s' % pin_info['pin'],
self._common_addon.getLocalizedString(32009),
self._common_addon.getLocalizedString(32010) %
('[B]%s[/B]' % KodiUtils.get_signin_server(),
'[B][COLOR lime]%s[/COLOR][/B]' % pin_info['pin']))
self._pin_dialog.show()
max_waiting_time = time.time() + self._DEFAULT_SIGNIN_TIMEOUT
while not self.cancel_operation() and max_waiting_time > time.time():
remaining = round(max_waiting_time - time.time())
percent = int(remaining / self._DEFAULT_SIGNIN_TIMEOUT * 100)
self._pin_dialog.update(
percent,
line3='[CR]' + self._common_addon.getLocalizedString(32011) %
str(int(remaining)) + '[CR][CR]Your source id is: %s' %
Utils.get_source_id(Utils.unicode(self._ip_before_pin)))
if int(remaining) % 5 == 0 or remaining == 1:
tokens_info = provider.fetch_tokens_info(
pin_info, request_params=request_params)
if self.cancel_operation() or tokens_info:
break
if self._system_monitor.waitForAbort(1):
break
self._pin_dialog.close()
if self.cancel_operation() or time.time() >= max_waiting_time:
return
if not tokens_info:
raise Exception('Unable to retrieve the auth2 tokens')
self._progress_dialog.update(
25, self._common_addon.getLocalizedString(32064), ' ', ' ')
try:
account = provider.get_account(request_params=request_params,
access_tokens=tokens_info)
except Exception as e:
raise UIException(32065, e)
if self.cancel_operation():
return
self._progress_dialog.update(
50, self._common_addon.getLocalizedString(32017))
try:
account['drives'] = provider.get_drives(
request_params=request_params, access_tokens=tokens_info)
except Exception as e:
raise UIException(32018, e)
if self.cancel_operation():
return
self._progress_dialog.update(
75, self._common_addon.getLocalizedString(32020))
try:
account['access_tokens'] = tokens_info
self._account_manager.save_account(account)
except Exception as e:
raise UIException(32021, e)
if self.cancel_operation():
return
self._progress_dialog.update(90)
try:
accounts = self._account_manager.get_accounts()
for drive in account['drives']:
driveid = drive['id']
Logger.debug('Looking for account %s...' % driveid)
if driveid in accounts:
drive = accounts[driveid]['drives'][0]
Logger.debug(drive)
if drive['id'] == driveid and drive['type'] == 'migrated':
Logger.debug('Account %s removed.' % driveid)
self._account_manager.remove_account(driveid)
except Exception as e:
pass
if self.cancel_operation():
return
self._progress_dialog.close()
KodiUtils.executebuiltin('Container.Refresh')
