def _select_stream_format(self, driveid, item_driveid=None, item_id=None):
url = None
self._progress_dialog.update(0, self._addon.getLocalizedString(32009))
self._provider.configure(self._account_manager, driveid)
self.get_item(driveid, item_driveid, item_id)
request = Request('https://drive.google.com/get_video_info', urllib.urlencode({'docid' : item_id}), {'authorization': 'Bearer %s' % self._provider.get_access_tokens()['access_token']})
response_text = request.request()
response_params = dict(urlparse.parse_qsl(response_text))
self._progress_dialog.close()
if Utils.get_safe_value(response_params, 'status', '') == 'ok':
fmt_list = Utils.get_safe_value(response_params, 'fmt_list', '').split(',')
stream_formats = [self._addon.getLocalizedString(32015)]
for fmt in fmt_list:
data = fmt.split('/')
stream_formats.append(data[1])
select = self._dialog.select(self._addon.getLocalizedString(32016), stream_formats, 8000)
if select > 0:
data = fmt_list[select-1].split('/')
fmt_stream_map = Utils.get_safe_value(response_params, 'fmt_stream_map', '').split(',')
for fmt in fmt_stream_map:
stream_data = fmt.split('|')
if stream_data[0] == data[0]:
url = stream_data[1]
break
if url:
cookie_header = ''
for cookie in request.response_cookies:
if cookie_header: cookie_header += ';'
cookie_header += cookie.name + '=' + cookie.value;
url += '|cookie=' + urllib.quote(cookie_header)
return url;
def create_nfo(item_id, item_driveid, nfo_path, provider):
url = provider.get_item(
item_driveid=item_driveid,
item_id=item_id,
include_download_info=True)["download_info"]["url"]
headers = {
"Authorization":
"Bearer %s" % provider.get_access_tokens()['access_token']
}
try:
response = Request(url, None, headers).request()
except:
Logger.error('Error on request to: %s' % url)
return False
f = None
try:
f = KodiUtils.file(nfo_path, 'w')
f.write(response)
except Exception as err:
Logger.error(err)
return False
finally:
if f:
f.close()
return True
def prepare_request(self,
method,
path,
parameters=None,
request_params=None,
access_tokens=None,
headers=None):
parameters = Utils.default(parameters, {})
access_tokens = Utils.default(access_tokens, {})
encoded_parameters = urllib.urlencode(parameters)
url = self._build_url(method, path, encoded_parameters)
request_params = self._wrap_on_exception(request_params)
if not headers:
headers = Utils.default(self._get_request_headers(), {})
content_type = Utils.get_safe_value(headers, 'content-type', '')
if content_type == 'application/json':
data = json.dumps(parameters)
else:
data = None if method == 'get' else encoded_parameters
if not access_tokens:
access_tokens = self.get_access_tokens()
self._validate_access_tokens(access_tokens, url, data, headers)
if time.time() > (access_tokens['date'] + access_tokens['expires_in']):
access_tokens.update(self.refresh_access_tokens(request_params))
self._validate_access_tokens(access_tokens,
'refresh_access_tokens', 'Unknown',
'Unknown')
self.persist_access_tokens(access_tokens)
headers['authorization'] = 'Bearer ' + access_tokens['access_token']
return Request(url, data, headers, **request_params)
def send_report(report):
if KodiUtils.get_addon_setting('report_error') == 'true':
report_url = KodiUtils.get_signin_server() + '/report'
t = threading.Thread(target=Request(
report_url, urllib.urlencode({'stacktrace': report})).request)
t.setDaemon(True)
t.start()
def _select_stream_format(self,
driveid,
item_driveid=None,
item_id=None,
auto=False):
url = None
if not auto:
self._progress_dialog.update(0,
self._addon.getLocalizedString(32009))
self._provider.configure(self._account_manager, driveid)
self._provider.get_item(item_driveid, item_id)
request = Request(
'https://drive.google.com/get_video_info',
urllib.parse.urlencode({'docid': item_id}), {
'authorization':
'Bearer %s' %
self._provider.get_access_tokens()['access_token']
})
response_text = request.request()
response_params = dict(urllib.parse.parse_qsl(response_text))
if not auto:
self._progress_dialog.close()
if Utils.get_safe_value(response_params, 'status', '') == 'ok':
fmt_list = Utils.get_safe_value(response_params, 'fmt_list',
'').split(',')
stream_formats = []
for fmt in fmt_list:
data = fmt.split('/')
stream_formats.append(data[1])
stream_formats.append(self._addon.getLocalizedString(32015))
Logger.debug('Stream formats: %s' % Utils.str(stream_formats))
select = -1
if auto:
select = self._auto_select_stream(stream_formats)
else:
select = self._dialog.select(
self._addon.getLocalizedString(32016), stream_formats,
8000, 0)
Logger.debug('Selected: %s' % Utils.str(select))
if select == -1:
self._cancel_operation = True
elif select != len(stream_formats) - 1:
data = fmt_list[select].split('/')
fmt_stream_map = Utils.get_safe_value(response_params,
'fmt_stream_map',
'').split(',')
for fmt in fmt_stream_map:
stream_data = fmt.split('|')
if stream_data[0] == data[0]:
url = stream_data[1]
break
if url:
cookie_header = ''
for cookie in request.response_cookies:
if cookie_header: cookie_header += ';'
cookie_header += cookie.name + '=' + cookie.value
url += '|cookie=' + urllib.parse.quote(cookie_header)
return url
def refresh_tokens(self, provider_name, refresh_token, request_params={}):
headers = {'addon': self.get_addon_header()}
body = urllib.urlencode({
'provider': provider_name,
'refresh_token': refresh_token
})
return Request(self._signin_url + '/refresh', body, headers,
**request_params).request_json()
def fetch_tokens_info(self, pin_info, request_params={}):
headers = {
'authorization':
'Basic ' + base64.b64encode(':' + pin_info['password']),
'addon':
self.get_addon_header()
}
return Request(self._signin_url + '/pin/' + pin_info['pin'], None,
headers, **request_params).request_json()
def fetch_tokens_info(self, pin_info, request_params=None):
request_params = self._wrap_on_exception(request_params)
headers = {
'authorization':
'Basic ' + base64.b64encode(':' + pin_info['password']),
'addon':
self.get_addon_header()
}
return Request(
KodiUtils.get_signin_server() + '/pin/' + pin_info['pin'], None,
headers, **request_params).request_json()
def refresh_tokens(self,
provider_name,
refresh_token,
request_params=None):
request_params = Utils.default(request_params, {})
headers = {'addon': self.get_addon_header()}
body = urllib.parse.urlencode({
'provider': provider_name,
'refresh_token': refresh_token
})
return Request(KodiUtils.get_signin_server() + '/refresh', body,
headers, **request_params).request_json()
def download(item, download_path, provider, on_update_download=None):
url = item['download_info']['url']
headers = None
if provider.download_requires_auth:
headers = {"Authorization":"Bearer %s"%provider.get_access_tokens()['access_token']}
try:
req = Request(url, None, headers, download_path = download_path, on_update_download = on_update_download)
req.request()
except Exception as e:
ErrorReport.handle_exception(e)
return False
return req.success
def create_strm(driveid, item, file_path, content_type, addon_url):
item_id = Utils.str(item['id'])
item_drive_id = Utils.default(Utils.get_safe_value(item, 'drive_id'), driveid)
f = None
try:
f = KodiUtils.file(file_path, 'w')
content = addon_url + '?' + urllib.urlencode({'action':'play', 'content_type': content_type, 'item_driveid': item_drive_id, 'item_id': item_id, 'driveid': driveid})
if item['name_extension'] == 'strm':
content = Request(item['download_info']['url'], None).request()
f.write(content)
except:
return False
finally:
if f:
f.close()
return True
def create_nfo(driveid, item, item_name, nfo_path):
item_enc = urllib.quote_plus(item_name.encode('utf-8'))
dl_url = DownloadServiceUtil.download_item(driveid, item, item_enc)
try:
response = Request(dl_url, None).request()
except:
Logger.error('Error on request to: %s' % dl_url)
return False
f = None
try:
f=KodiUtils.file(nfo_path,'w')
f.write(response)
except Exception as err:
Logger.error(err)
return False
finally:
if f:
f.close()
return True
def rpc(addonid, method, args=None, kwargs=None, request_id=None):
if not request_id:
request_id = str(uuid.uuid4())
cmd = {'method': method}
if args:
cmd.update({'args': args})
if kwargs:
cmd.update({'kwargs': kwargs})
cmd = repr(cmd)
result = eval(
Request('http://%s:%s/%s' %
(RpcService._interface,
KodiUtils.get_service_port(RpcService.name,
addonid), RpcService.name),
cmd, {
'content-length': len(cmd),
'request-id': request_id
},
tries=1).request())
return result
def get_subtitles(self):
try:
from clouddrive.common.remote.request import Request
from clouddrive.common.service.download import DownloadServiceUtil
response = Request(self.getPlayingFile() + '?subtitles',
None).request_json()
if response and 'driveid' in response and 'subtitles' in response:
driveid = response['driveid']
subtitles = response['subtitles']
for subtitle in subtitles:
url = DownloadServiceUtil.build_download_url(
driveid,
Utils.default(
Utils.get_safe_value(subtitle, 'drive_id'),
driveid), subtitle['id'],
urllib.quote(Utils.str(subtitle['name'])))
Logger.debug('subtitle: %s' % url)
self.setSubtitles(url)
except Exception as e:
Logger.error(e)
from clouddrive.common.remote.errorreport import ErrorReport
ErrorReport.handle_exception(e)
def send_report(self, report):
if KodiUtils.get_addon_setting(
'report_error', 'script.module.clouddrive.common') == 'true':
Request(self._report_url, urllib.urlencode({'stacktrace':
report})).request()
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(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.add_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.load()
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')
def create_pin(self, provider_name, request_params={}):
headers = {'addon': self.get_addon_header()}
body = urllib.urlencode({'provider': provider_name})
return Request(self._signin_url + '/pin', body, headers,
**request_params).request_json()
def create_pin(self, provider_name, request_params=None):
request_params = Utils.default(request_params, {})
headers = {'addon': self.get_addon_header()}
body = urllib.parse.urlencode({'provider': provider_name})
return Request(KodiUtils.get_signin_server() + '/pin', body, headers,
**request_params).request_json()