def login(ask=1, **kwargs):
ask = int(ask)
creds = get_credentials()
if len(creds['username']) < 1 or len(creds['password']) < 1 or ask == 1:
user_info = plugin_ask_for_creds(creds)
if user_info['result']:
set_credentials(username=user_info['username'], password=user_info['password'])
login_result = api_login()
if not login_result['result']:
profile_settings = load_profile(profile_id=1)
profile_settings['last_login_success'] = 0
profile_settings['pswd'] = ''
save_profile(profile_id=1, profile=profile_settings)
plugin_login_error(login_result)
else:
profile_settings = load_profile(profile_id=1)
profile_settings['last_login_success'] = 1
save_profile(profile_id=1, profile=profile_settings)
gui.ok(message=_.LOGIN_SUCCESS)
api_get_channels()
plugin_post_login()
gui.refresh()
def plugin_process_playdata(playdata):
creds = get_credentials()
profile_settings = load_profile(profile_id=1)
CDMHEADERS = {
'User-Agent': DEFAULT_USER_AGENT,
'X-Client-Id': CONST_DEFAULT_CLIENTID + '||' + DEFAULT_USER_AGENT,
'X-OESP-Token': profile_settings['access_token'],
'X-OESP-Username': creds['username'],
'X-OESP-License-Token': profile_settings['drm_token'],
'X-OESP-DRM-SchemeIdUri': 'urn:uuid:edef8ba9-79d6-4ace-a3c8-27dcd51d21ed',
'X-OESP-Content-Locator': playdata['locator'],
}
params = []
try:
params.append(('_', 'renew_token'))
params.append(('path', str(playdata['path']).encode('utf-8')))
params.append(('locator', str(playdata['locator']).encode('utf-8')))
except:
params.append(('_', 'renew_token'))
params.append(('path', playdata['path']))
params.append(('locator', playdata['locator']))
item_inputstream = inputstream.Widevine(
license_key = playdata['license'],
media_renewal_url = 'plugin://{0}/?{1}'.format(ADDON_ID, urlencode(encode_obj(params))),
media_renewal_time = 60,
)
return item_inputstream, CDMHEADERS
def api_get_headers():
creds = get_credentials()
username = creds['username']
profile_settings = load_profile(profile_id=1)
headers = {
'User-Agent':
DEFAULT_USER_AGENT,
'X-Client-Id':
'{clientid}||{defaultagent}'.format(clientid=CONST_DEFAULT_CLIENTID,
defaultagent=DEFAULT_USER_AGENT),
}
if check_key(profile_settings, 'ziggo_profile_id') and len(
str(profile_settings['ziggo_profile_id'])) > 0:
headers['X-OESP-Profile-Id'] = profile_settings['ziggo_profile_id']
if check_key(
profile_settings,
'access_token') and len(str(profile_settings['access_token'])) > 0:
headers['X-OESP-Token'] = profile_settings['access_token']
if len(str(username)) > 0:
headers['X-OESP-Username'] = username
return headers
def api_get_session_token():
creds = get_credentials()
username = creds['username']
profile_settings = load_profile(profile_id=1)
headers = {
'User-Agent': DEFAULT_USER_AGENT,
'X-Client-Id': CONST_DEFAULT_CLIENTID + "||" + DEFAULT_USER_AGENT,
}
download = api_download(url='{session_url}?token=true'.format(
session_url=CONST_URLS['session_url']),
type='post',
headers=headers,
data={
"username": username,
"refreshToken":
profile_settings['refresh_token']
},
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if not code or not data or not check_key(data, 'oespToken'):
if not code:
code = {}
if not data:
data = {}
return {'code': code, 'data': data, 'result': False}
betelenet_profile_id = ''
household_id = ''
try:
betelenet_profile_id = data['customer']['sharedProfileId']
except:
pass
try:
household_id = data['customer']['householdId']
except:
pass
profile_settings['access_token'] = data['oespToken']
profile_settings['refresh_token'] = data['refreshToken']
profile_settings['refresh_token_expiry'] = data['refreshTokenExpiry']
profile_settings['betelenet_profile_id'] = betelenet_profile_id
profile_settings['household_id'] = household_id
save_profile(profile_id=1, profile=profile_settings)
if len(str(profile_settings['watchlist_id'])) == 0:
api_get_watchlist_id()
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(ADDON_PROFILE + 'stream_cookies')
except:
pass
profile_settings = load_profile(profile_id=1)
profile_settings['access_token'] = ''
profile_settings['ziggo_profile_id'] = ''
profile_settings['household_id'] = ''
profile_settings['watchlist_id'] = ''
save_profile(profile_id=1, profile=profile_settings)
HEADERS = {
'User-Agent': DEFAULT_USER_AGENT,
'X-Client-Id': CONST_DEFAULT_CLIENTID + "||" + DEFAULT_USER_AGENT,
}
download = api_download(url=CONST_API_URLS[0]['session_url'], type='post', headers=HEADERS, data={"username": username, "password": password}, json_data=True, return_json=True)
data = download['data']
code = download['code']
if not code or not data or not check_key(data, 'oespToken'):
if not code:
code = {}
if not data:
data = {}
return { 'code': code, 'data': data, 'result': False }
ziggo_profile_id = data['customer']['sharedProfileId']
household_id = data['customer']['householdId']
profile_settings['access_token'] = data['oespToken']
profile_settings['ziggo_profile_id'] = ziggo_profile_id
profile_settings['household_id'] = household_id
save_profile(profile_id=1, profile=profile_settings)
if len(str(profile_settings['watchlist_id'])) == 0:
api_get_watchlist_id()
return { 'code': code, 'data': data, 'result': True }
def api_get_headers():
creds = get_credentials()
username = creds['username']
profile_settings = load_profile(profile_id=1)
HEADERS = {
'User-Agent': DEFAULT_USER_AGENT,
'X-Client-Id': CONST_DEFAULT_CLIENTID + '||' + DEFAULT_USER_AGENT,
'X-OESP-Token': profile_settings['access_token'],
'X-OESP-Username': username,
}
HEADERS['X-OESP-Profile-Id'] = profile_settings['ziggo_profile_id']
return HEADERS
def api_get_headers():
creds = get_credentials()
username = creds['username']
profile_settings = load_profile(profile_id=1)
HEADERS = {
'User-Agent':
profile_settings['user_agent'],
'X-Client-Id':
profile_settings['client_id'] + '||' + profile_settings['user_agent'],
'X-OESP-Token':
profile_settings['access_token'],
'X-OESP-Username':
username,
}
if profile_settings['base_v3'] == 1:
HEADERS['X-OESP-Profile-Id'] = profile_settings['ziggo_profile_id']
return HEADERS
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(os.path.join(ADDON_PROFILE, 'stream_cookies'))
except:
pass
session_url = '{api_url}/subscriber/authenticate/by-password'.format(api_url=CONST_URLS['api'])
session_post_data = {
"DeviceType": 16,
"DistributionChannel": '871435e3-2d31-4d4f-9004-96c6a8011656',
"Language": 'en-GB',
"Login": username,
"Password": password
}
headers = {
"Content-Type": "application/json",
"apikey": "fCUCjWrKPu9ylJwRAv8BpGLEgiAuThx7",
"CD-DeviceType": '16',
"CD-DistributionChannel": '871435e3-2d31-4d4f-9004-96c6a8011656',
'User-Agent': 'RaceControl'
}
download = api_download(url=session_url, type='post', headers=headers, data=session_post_data, json_data=True, return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(data, 'SessionId') or not data['data']['subscriptionStatus'] == 'active':
return { 'code': code, 'data': data, 'result': False }
profile_settings = load_profile(profile_id=1)
profile_settings['subscriptionToken'] = data["data"]["subscriptionToken"]
save_profile(profile_id=1, profile=profile_settings)
return { 'code': code, 'data': data, 'result': True }
def api_login(force=False):
creds = get_credentials()
username = creds['username']
password = creds['password']
use_old = False
loggedin = False
profile_settings = load_profile(profile_id=1)
code_verifier = base64.urlsafe_b64encode(os.urandom(40)).decode('utf-8')
code_verifier = re.sub('[^a-zA-Z0-9]+', '', code_verifier)
code_challenge = hashlib.sha256(code_verifier.encode('utf-8')).digest()
code_challenge = base64.urlsafe_b64encode(code_challenge).decode('utf-8')
code_challenge = code_challenge.replace('=', '')
state = ''.join(
random.choice(string.ascii_lowercase + string.digits)
for _ in range(32))
base_authorization_url = "{id_url}/connect/authorize".format(
id_url=CONST_ID_URL)
if check_key(profile_settings, 'id_token') and force == False:
id_token_hint = profile_settings['id_token']
authorization_url = "{base_url}?response_type=code&client_id=triple-web&scope=openid api&redirect_uri={app_url}/callback-silent.html&state={state}&code_challenge={code_challenge}&code_challenge_method=S256&response_mode=query&prompt=none&id_token_hint={id_token_hint}".format(
base_url=base_authorization_url,
app_url=CONST_APP_URL,
state=state,
code_challenge=code_challenge,
id_token_hint=id_token_hint)
download = api_download(url=authorization_url,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 302:
redirect = download['headers']['Location']
query = urlparse(redirect).query
redirect_params = parse_qs(query)
auth_code = redirect_params['code'][0]
download = api_download(url=redirect,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 200:
post_data = {
"client_id":
'triple-web',
"code":
auth_code,
"redirect_uri":
"{app_url}/callback-silent.html".format(
app_url=CONST_APP_URL),
"code_verifier":
code_verifier,
"grant_type":
"authorization_code"
}
download = api_download(
url="{id_url}/connect/token".format(id_url=CONST_ID_URL),
type='post',
headers=None,
data=post_data,
json_data=False,
return_json=True,
allow_redirects=False)
data = download['data']
code = download['code']
if data and code == 200 and check_key(
data, 'id_token') and check_key(data, 'access_token'):
loggedin = True
if not loggedin:
try:
os.remove(ADDON_PROFILE + 'stream_cookies')
except:
pass
try:
profile_settings['access_token'] = ''
profile_settings['access_token_age'] = 0
profile_settings['id_token'] = ''
save_profile(profile_id=1, profile=profile_settings)
except:
pass
authorization_url = "{base_url}?response_type=code&client_id=triple-web&scope=openid api&redirect_uri={app_url}/callback&state={state}&code_challenge={code_challenge}&code_challenge_method=S256&response_mode=query".format(
base_url=base_authorization_url,
app_url=CONST_APP_URL,
state=state,
code_challenge=code_challenge)
download = api_download(url=authorization_url,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 302:
redirect = download['headers']['Location']
download = api_download(url=redirect,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 200:
soup = bs4(data, 'html.parser')
token = None
try:
token = soup.find(
'input',
{'name': '__RequestVerificationToken'})['value']
except:
pass
query = urlparse(redirect).query
request_params = parse_qs(query)
if token and request_params and check_key(
request_params, 'ReturnUrl'):
post_data = {
"ReturnUrl": request_params['ReturnUrl'][0],
"EmailAddress": username,
"Password": password,
"RememberLogin": "******",
"button": "login",
"__RequestVerificationToken": token
}
download = api_download(url=redirect,
type='post',
headers=None,
data=post_data,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 302:
redirect = download['headers']['Location']
download = api_download(url=CONST_ID_URL + redirect,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 302:
redirect = download['headers']['Location']
query = urlparse(redirect).query
redirect_params = parse_qs(query)
auth_code = redirect_params['code'][0]
download = api_download(url=redirect,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
if code == 200:
post_data = {
"client_id":
'triple-web',
"code":
auth_code,
"redirect_uri":
"{app_url}/callback".format(
app_url=CONST_APP_URL),
"code_verifier":
code_verifier,
"grant_type":
"authorization_code"
}
download = api_download(
url="{id_url}/connect/token".format(
id_url=CONST_ID_URL),
type='post',
headers=None,
data=post_data,
json_data=False,
return_json=True,
allow_redirects=False)
data = download['data']
code = download['code']
if data and check_key(
data, 'id_token') and check_key(
data, 'access_token'):
loggedin = True
if not loggedin:
return {'code': code, 'data': data, 'result': False}
try:
profile_settings['id_token'] = data['id_token']
profile_settings['access_token'] = data['access_token']
profile_settings['access_token_age'] = int(time.time())
save_profile(profile_id=1, profile=profile_settings)
except:
pass
return {'code': code, 'data': data, 'result': True}
def api_login(force=False):
creds = get_credentials()
username = creds['username']
password = creds['password']
use_old = False
profile_settings = load_profile(profile_id=1)
if not check_key(profile_settings, 'base_resource_key') or not check_key(
profile_settings, 'base_resource_secret') or len(
profile_settings['base_resource_key']) == 0 or len(
profile_settings['base_resource_secret']
) == 0 or force == True:
try:
os.remove(ADDON_PROFILE + 'stream_cookies')
except:
pass
try:
profile_settings['base_resource_key'] = ''
profile_settings['base_resource_secret'] = ''
profile_settings['resource_key'] = ''
profile_settings['resource_secret'] = ''
profile_settings['resource_verifier'] = ''
save_profile(profile_id=1, profile=profile_settings)
except:
pass
request_token_url = '{base_url}/OAuth/GetRequestToken'.format(
base_url=CONST_BASE_URL)
oauth = OAuth1('key', client_secret='secret', callback_uri='null')
download = api_download(url=request_token_url,
type='post',
headers=None,
data=None,
json_data=False,
return_json=False,
auth=oauth)
data = download['data']
code = download['code']
credentials = parse_qs(data)
base_resource_owner_key = credentials.get('oauth_token')[0]
base_resource_owner_secret = credentials.get('oauth_token_secret')[0]
login_url = '{base_url}/account/applogin'.format(
base_url=CONST_BASE_URL)
session_post_data = {
"username": username,
"password": password,
}
headers = {'content-type': 'application/x-www-form-urlencoded'}
download = api_download(url=login_url,
type='post',
headers=headers,
data=session_post_data,
json_data=False,
return_json=False)
data = download['data']
code = download['code']
if code != 200 and code != 302:
return {'code': code, 'data': data, 'result': False}
authorization_url = "{base_url}/OAuth/Authorize?oauth_token={token}".format(
base_url=CONST_BASE_URL, token=base_resource_owner_key)
download = api_download(url=authorization_url,
type='get',
headers=None,
data=None,
json_data=False,
return_json=False,
allow_redirects=False)
data = download['data']
code = download['code']
regex = r"oauth_verifier=([a-zA-Z0-9]+)"
matches = re.finditer(regex, data, re.MULTILINE)
resource_verifier = ''
try:
for match in matches:
resource_verifier = match.group(1)
except:
pass
if len(resource_verifier) == 0:
return {'code': code, 'data': data, 'result': False}
else:
use_old = True
base_resource_owner_key = profile_settings['base_resource_key']
base_resource_owner_secret = profile_settings['base_resource_secret']
resource_verifier = profile_settings['resource_verifier']
access_token_url = '{base_url}/OAuth/GetAccessToken'.format(
base_url=CONST_BASE_URL)
oauth = OAuth1('key',
client_secret='secret',
callback_uri='null',
resource_owner_key=base_resource_owner_key,
resource_owner_secret=base_resource_owner_secret,
verifier=resource_verifier)
download = api_download(url=access_token_url,
type='post',
headers=None,
data=None,
json_data=False,
return_json=False,
auth=oauth)
data = download['data']
code = download['code']
credentials = parse_qs(data)
try:
resource_owner_key = credentials.get('oauth_token')[0]
resource_owner_secret = credentials.get('oauth_token_secret')[0]
except:
if use_old == True:
return api_login(force=True)
return {'code': code, 'data': data, 'result': False}
try:
profile_settings['base_resource_key'] = base_resource_owner_key
profile_settings['base_resource_secret'] = base_resource_owner_secret
profile_settings['resource_key'] = resource_owner_key
profile_settings['resource_secret'] = resource_owner_secret
profile_settings['resource_verifier'] = resource_verifier
save_profile(profile_id=1, profile=profile_settings)
except:
pass
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
query = "UPDATE `vars` SET `access_token`='', `household_id`='', `ziggo_profile_id`='' WHERE profile_id={profile_id}".format(
profile_id=1)
query_settings(query=query,
return_result=False,
return_insert=False,
commit=True)
profile_settings = load_profile(profile_id=1)
user_agent = profile_settings['user_agent']
HEADERS = {
'User-Agent': user_agent,
'X-Client-Id': profile_settings['client_id'] + "||" + user_agent,
}
download = api_download(url=profile_settings['session_url'],
type='post',
headers=HEADERS,
data={
"username": username,
"password": password
},
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if code and data and check_key(
data, 'reason') and data['reason'] == 'wrong backoffice':
if profile_settings['base_v3'] == 0:
query = "UPDATE `vars` SET `base_v3`=1 WHERE profile_id={profile_id}".format(
profile_id=1)
query_settings(query=query,
return_result=False,
return_insert=False,
commit=True)
else:
query = "UPDATE `vars` SET `base_v3`=0 WHERE profile_id={profile_id}".format(
profile_id=1)
query_settings(query=query,
return_result=False,
return_insert=False,
commit=True)
update_settings()
download_files()
profile_settings = load_profile(profile_id=1)
download = api_download(url=profile_settings['session_url'],
type='post',
headers=HEADERS,
data={
"username": username,
"password": password
},
json_data=True,
return_json=True)
if not code or not data or not check_key(data, 'oespToken'):
if not code:
code = {}
if not data:
data = {}
return {'code': code, 'data': data, 'result': False}
ziggo_profile_id = ''
household_id = ''
if profile_settings['base_v3'] == 1:
ziggo_profile_id = data['customer']['sharedProfileId']
household_id = data['customer']['householdId']
query = "UPDATE `vars` SET `access_token`='{access_token}', `ziggo_profile_id`='{ziggo_profile_id}', `household_id`='{household_id}' WHERE profile_id={profile_id}".format(
access_token=data['oespToken'],
ziggo_profile_id=ziggo_profile_id,
household_id=household_id,
profile_id=1)
query_settings(query=query,
return_result=False,
return_insert=False,
commit=True)
if profile_settings['base_v3'] == 1:
if len(unicode(profile_settings['watchlist_id'])) == 0:
api_get_watchlist_id()
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(os.path.join(ADDON_PROFILE, 'stream_cookies'))
except:
pass
profile_settings = load_profile(profile_id=1)
profile_settings['access_token'] = ''
profile_settings['ziggo_profile_id'] = ''
profile_settings['household_id'] = ''
profile_settings['watchlist_id'] = ''
save_profile(profile_id=1, profile=profile_settings)
headers = {
'User-Agent':
DEFAULT_USER_AGENT,
'X-Client-Id':
'{clientid}||{defaultagent}'.format(clientid=CONST_DEFAULT_CLIENTID,
defaultagent=DEFAULT_USER_AGENT),
}
download = api_download(url=CONST_URLS['session_url'],
type='post',
headers=headers,
data={
"username": username,
"password": password
},
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if code and data and check_key(
data, 'reason') and data['reason'] == 'wrong backoffice':
return {'code': code, 'data': data, 'result': False}
if not code or not data or not check_key(data, 'oespToken'):
if not code:
code = {}
if not data:
data = {}
return {'code': code, 'data': data, 'result': False}
ziggo_profile_id = ''
household_id = ''
try:
ziggo_profile_id = data['customer']['sharedProfileId']
except:
pass
try:
household_id = data['customer']['householdId']
except:
pass
profile_settings['access_token'] = data['oespToken']
profile_settings['ziggo_profile_id'] = ziggo_profile_id
profile_settings['household_id'] = household_id
save_profile(profile_id=1, profile=profile_settings)
if len(str(profile_settings['watchlist_id'])) == 0:
api_get_watchlist_id()
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(os.path.join(ADDON_PROFILE, 'stream_cookies'))
except:
pass
profile_settings = load_profile(profile_id=1)
profile_settings['access_token'] = ''
profile_settings['refresh_token'] = ''
profile_settings['refresh_token_expiry'] = 0
profile_settings['betelenet_profile_id'] = ''
profile_settings['household_id'] = ''
profile_settings['watchlist_id'] = ''
save_profile(profile_id=1, profile=profile_settings)
headers = {
'User-Agent':
DEFAULT_USER_AGENT,
'X-Client-Id':
'{clientid}||{defaultagent}'.format(clientid=CONST_DEFAULT_CLIENTID,
defaultagent=DEFAULT_USER_AGENT),
}
download = api_download(url=CONST_URLS['authorization_url'],
type='get',
headers=headers,
data=None,
json_data=False,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'session') or not check_key(
data['session'], 'validityToken') or not check_key(
data['session'], 'state') or not check_key(
data['session'], 'authorizationUri'):
return {'code': code, 'data': data, 'result': False}
validityToken = data['session']['validityToken']
state = data['session']['state']
download = api_download(url=data['authorizationUri'],
type='get',
headers=headers,
data=None,
json_data=False,
return_json=False)
data = download['data']
code = download['code']
if not code or not code == 302:
return {'code': code, 'data': data, 'result': False}
formdata = {
"j_username": username,
"j_password": password,
"rememberme": "true"
}
download = api_download(url=CONST_URLS['login_url'],
type='post',
headers=headers,
data=formdata,
json_data=False,
return_json=False)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not 'SSO Login Success' in data:
return {'code': code, 'data': data, 'result': False}
params = parse_qs(urlparse(download['url']).query)
auth_code = params.get('code')[0]
jsondata = {
"authorizationGrant": {
"authorizationCode": auth_code,
"validityToken": validityToken,
"state": state
}
}
download = api_download(url=CONST_URLS['authorization_url'],
type='post',
headers=headers,
data=jsondata,
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'refreshToken') or not check_key(data, 'username'):
return {'code': code, 'data': data, 'result': False}
profile_settings['refresh_token'] = data['refreshToken']
save_profile(profile_id=1, profile=profile_settings)
return api_get_session_token()
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(ADDON_PROFILE + 'stream_cookies')
except:
pass
profile_settings = load_profile(profile_id=1)
profile_settings['csrf_token'] = ''
profile_settings['user_filter'] = ''
if not profile_settings or not check_key(
profile_settings, 'devicekey') or len(
profile_settings['devicekey']) == 0:
devicekey = ''.join(random.choice(string.digits) for _ in range(10))
profile_settings['devicekey'] = devicekey
save_profile(profile_id=1, profile=profile_settings)
login_url = '{base_url}/VSP/V3/Authenticate?from=throughMSAAccess'.format(
base_url=CONST_BASE_URL)
session_post_data = {
"authenticateBasic": {
'VUID':
'6_7_{devicekey}'.format(devicekey=profile_settings['devicekey']),
'clientPasswd':
password,
'isSupportWebpImgFormat':
'0',
'lang':
'nl',
'needPosterTypes': [
'1',
'2',
'3',
'4',
'5',
'6',
'7',
],
'timeZone':
'Europe/Amsterdam',
'userID':
username,
'userType':
'0',
},
'authenticateDevice': {
'CADeviceInfos': [
{
'CADeviceID': profile_settings['devicekey'],
'CADeviceType': '7',
},
],
'deviceModel':
'3103_PCClient',
'physicalDeviceID':
profile_settings['devicekey'],
'terminalID':
profile_settings['devicekey'],
},
'authenticateTolerant': {
'areaCode': '',
'bossID': '',
'subnetID': '',
'templateName': '',
'userGroup': '',
},
}
download = api_download(url=login_url,
type='post',
headers=None,
data=session_post_data,
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'result') or not check_key(
data['result'], 'retCode'
) or not data['result']['retCode'] == '000000000' or not check_key(
data, 'csrfToken'):
if check_key(data, 'result') and check_key(
data['result'], 'retCode'
) and data['result']['retCode'] == "157022007" and check_key(
data, 'devices'):
for row in data['devices']:
if not check_key(row, 'name') and check_key(
row, 'deviceModel'
) and check_key(row, 'status') and check_key(
row, 'onlineState') and check_key(
row, 'physicalDeviceID'
) and row['deviceModel'] == '3103_PCClient' and row[
'status'] == '1' and row['onlineState'] == '0':
profile_settings['devicekey'] = row['physicalDeviceID']
save_profile(profile_id=1, profile=profile_settings)
return api_login()
return {'code': code, 'data': data, 'result': False}
profile_settings['csrf_token'] = data['csrfToken']
profile_settings['user_filter'] = data['userFilter']
save_profile(profile_id=1, profile=profile_settings)
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
query = "UPDATE `vars` SET `csrf_token`='', `cookies`='', `user_filter`='' WHERE profile_id={profile_id}".format(profile_id=1)
query_settings(query=query, return_result=False, return_insert=False, commit=True)
profile_settings = load_profile(profile_id=1)
if len(profile_settings['devicekey']) == 0:
devicekey = ''.join(random.choice(string.digits) for _ in range(10))
query = "UPDATE `vars` SET `devicekey`='{devicekey}' WHERE profile_id={profile_id}".format(devicekey=devicekey, profile_id=1)
query_settings(query=query, return_result=False, return_insert=False, commit=True)
login_url = '{base_url}/VSP/V3/Authenticate?from=throughMSAAccess'.format(base_url=CONST_BASE_URL)
session_post_data = {
"authenticateBasic": {
'VUID': '6_7_{devicekey}'.format(devicekey=profile_settings['devicekey']),
'clientPasswd': password,
'isSupportWebpImgFormat': '0',
'lang': 'nl',
'needPosterTypes': [
'1',
'2',
'3',
'4',
'5',
'6',
'7',
],
'timeZone': 'Europe/Amsterdam',
'userID': username,
'userType': '0',
},
'authenticateDevice': {
'CADeviceInfos': [
{
'CADeviceID': profile_settings['devicekey'],
'CADeviceType': '7',
},
],
'deviceModel': '3103_PCClient',
'physicalDeviceID': profile_settings['devicekey'],
'terminalID': profile_settings['devicekey'],
},
'authenticateTolerant': {
'areaCode': '',
'bossID': '',
'subnetID': '',
'templateName': '',
'userGroup': '',
},
}
download = api_download(url=login_url, type='post', headers=None, data=session_post_data, json_data=True, return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(data, 'result') or not check_key(data['result'], 'retCode') or not data['result']['retCode'] == '000000000' or not check_key(data, 'csrfToken'):
if check_key(data, 'result') and check_key(data['result'], 'retCode') and data['result']['retCode'] == "157022007" and check_key(data, 'devices'):
for row in data['devices']:
if not check_key(row, 'name') and check_key(row, 'deviceModel') and check_key(row, 'status') and check_key(row, 'onlineState') and check_key(row, 'physicalDeviceID') and row['deviceModel'] == '3103_PCClient' and row['status'] == '1' and row['onlineState'] == '0':
query = "UPDATE `vars` SET `devicekey`='{devicekey}' WHERE profile_id={profile_id}".format(devicekey=row['physicalDeviceID'], profile_id=1)
query_settings(query=query, return_result=False, return_insert=False, commit=True)
return api_login()
return { 'code': code, 'data': data, 'result': False }
query = "UPDATE `vars` SET `csrf_token`='{csrf_token}', `user_filter`='{user_filter}' WHERE profile_id={profile_id}".format(csrf_token=data['csrfToken'], user_filter=data['userFilter'], profile_id=1)
query_settings(query=query, return_result=False, return_insert=False, commit=True)
return { 'code': code, 'data': data, 'result': True }
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(ADDON_PROFILE + 'stream_cookies')
except:
pass
profile_settings = load_profile(profile_id=1)
if not profile_settings or not check_key(
profile_settings, 'devicekey') or len(
profile_settings['devicekey']) == 0:
devicekey = ''.join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for _ in range(64))
profile_settings['devicekey'] = devicekey
save_profile(profile_id=1, profile=profile_settings)
session_url = '{api_url}/USER/SESSIONS/'.format(api_url=CONST_DEFAULT_API)
email_or_pin = settings.getBool(key='email_instead_of_customer')
if email_or_pin:
session_post_data = {
"credentialsExtAuth": {
'credentials': {
'loginType': 'UsernamePassword',
'username': username,
'password': password,
'appId': 'KPN',
},
'remember': 'Y',
'deviceInfo': {
'deviceId': profile_settings['devicekey'],
'deviceIdType': 'DEVICEID',
'deviceType': 'PCTV',
'deviceVendor': DEFAULT_BROWSER_NAME,
'deviceModel': DEFAULT_BROWSER_VERSION,
'deviceFirmVersion': DEFAULT_OS_NAME,
'appVersion': DEFAULT_OS_VERSION
}
},
}
else:
session_post_data = {
"credentialsStdAuth": {
'username': username,
'password': password,
'remember': 'Y',
'deviceRegistrationData': {
'deviceId': profile_settings['devicekey'],
'accountDeviceIdType': 'DEVICEID',
'deviceType': 'PCTV',
'vendor': DEFAULT_BROWSER_NAME,
'model': DEFAULT_BROWSER_VERSION,
'deviceFirmVersion': DEFAULT_OS_NAME,
'appVersion': DEFAULT_OS_VERSION
}
},
}
download = api_download(url=session_url,
type='post',
headers=None,
data=session_post_data,
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'resultCode') or not data['resultCode'] == 'OK':
return {'code': code, 'data': data, 'result': False}
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
remove_file(file='stream_cookies', ext=False)
profile_settings = load_profile(profile_id=1)
profile_settings['vlid'] = ''
profile_settings['profile_id'] = ''
save_profile(profile_id=1, profile=profile_settings)
headers = {
"Origin": CONST_URLS['gigya'],
"Referer": "{gigya_url}/".format(gigya_url=CONST_URLS['gigya']),
}
session_post_data = {
'loginID': username,
'password': password,
'sessionExpiration': '0',
'targetEnv': 'jssdk',
'include': 'profile,data',
'includeUserInfo': 'true',
'lang': 'en',
'APIKey':
'3_t2Z1dFrbWR-IjcC-Bod1kei6W91UKmeiu3dETVG5iKaY4ILBRzVsmgRHWWo0fqqd',
'sdk': 'js_latest',
'authMode': 'cookie',
'pageURL': "{base_url}/".format(base_url=CONST_URLS['base']),
'format': 'json',
}
login_url = '{gigya_url}/accounts.login'.format(
gigya_url=CONST_URLS['gigya'])
download = api_download(url=login_url,
type='post',
headers=headers,
data=session_post_data,
json_data=False,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'signatureTimestamp') or not check_key(
data, 'UID') or not check_key(data, 'UIDSignature'):
return {'code': code, 'data': data, 'result': False}
hash_url = '{base_url}/api/v3/login/hash'.format(
base_url=CONST_URLS['base'])
headers = api_get_headers(personal=False)
headers["Referer"] = "{base_url}/inloggen".format(
base_url=CONST_URLS['base'])
headers["Origin"] = CONST_URLS['base']
session_post_data = {
'UID': data['UID'],
'UIDSignature': data['UIDSignature'],
'signatureTimestamp': data['signatureTimestamp'],
}
download = api_download(url=hash_url,
type='post',
headers=headers,
data=session_post_data,
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'vlHash'):
return {'code': code, 'data': data, 'result': False}
profile_settings['vlid'] = data['vlHash']
cookies = load_file(file='stream_cookies', isJSON=True)
if not cookies:
cookies = {}
cookies['vlId'] = data['vlHash']
write_file(file='stream_cookies', data=cookies, isJSON=True)
profile_url = '{base_url}/api/v3/profiles'.format(
base_url=CONST_URLS['base'])
headers = api_get_headers(personal=False)
headers["Referer"] = "{base_url}/profielkeuze".format(
base_url=CONST_URLS['base'])
download = api_download(url=profile_url,
type='get',
headers=headers,
data=None,
json_data=False,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(data[0], 'id'):
return {'code': code, 'data': data, 'result': False}
save_profile(profile_id=1, profile=profile_settings)
api_set_profile()
return {'code': code, 'data': data, 'result': True}
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
try:
os.remove(ADDON_PROFILE + 'stream_cookies')
except:
pass
profile_settings = load_profile(profile_id=1)
profile_settings['session_token'] = ''
if not profile_settings or not check_key(profile_settings, 'devicekey') or len(profile_settings['devicekey']) == 0:
devicekey = 'w{uuid}'.format(uuid=uuid.uuid4())
profile_settings['devicekey'] = devicekey
save_profile(profile_id=1, profile=profile_settings)
oauth = ''
auth_url = '{login_url}/authenticate?redirect_uri=https%3A%2F%2Flivetv.canaldigitaal.nl%2Fauth.aspx&state={state}&response_type=code&scope=TVE&client_id=StreamGroup'.format(login_url=CONST_LOGIN_URL, state=int(time.time()))
download = api_download(url=auth_url, type='get', headers=None, data=None, json_data=False, return_json=False, allow_redirects=False)
data = download['data']
code = download['code']
if not code or not code == 200 or not data:
return { 'code': code, 'data': data, 'result': False }
headers = CONST_LOGIN_HEADERS
headers.update({'Referer': auth_url})
session_post_data = {
"Password": password,
"Username": username,
}
download = api_download(url=CONST_LOGIN_URL, type='post', headers=headers, data=session_post_data, json_data=False, return_json=False, allow_redirects=False)
data = download['data']
code = download['code']
headers = download['headers']
if not code or not code == 302:
return { 'code': code, 'data': data, 'result': False }
params = parse_qs(urlparse(headers['Location']).query)
if check_key(params, 'code'):
oauth = params['code'][0]
if len(oauth) == 0:
return { 'code': code, 'data': data, 'result': False }
challenge_url = "{base_url}/m7be2iphone/challenge.aspx".format(base_url=CONST_BASE_URL)
session_post_data = {
"autotype": "nl",
"app": "cds",
"prettyname": DEFAULT_BROWSER_NAME,
"model": "web",
"serial": profile_settings['devicekey'],
"oauthcode": oauth
}
headers = {'Content-Type': 'application/json;charset=UTF-8'}
download = api_download(url=challenge_url, type='post', headers=headers, data=session_post_data, json_data=True, return_json=True, allow_redirects=False)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(data, 'id') or not check_key(data, 'secret'):
return { 'code': code, 'data': data, 'result': False }
login_url = "{base_url}/m7be2iphone/login.aspx".format(base_url=CONST_BASE_URL)
headers = {'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8'}
secret = '{id}\t{secr}'.format(id=data['id'], secr=data['secret'])
session_post_data = {
"secret": secret,
"uid": profile_settings['devicekey'],
"app": "cds",
}
download = api_download(url=login_url, type='post', headers=headers, data=session_post_data, json_data=False, return_json=False, allow_redirects=False)
data = download['data']
code = download['code']
if not code or not code == 302:
return { 'code': code, 'data': data, 'result': False }
ssotoken_url = "{base_url}/m7be2iphone/capi.aspx?z=ssotoken".format(base_url=CONST_BASE_URL)
download = api_download(url=ssotoken_url, type='get', headers=None, data=None, json_data=False, return_json=True, allow_redirects=False)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(data, 'ssotoken'):
return { 'code': code, 'data': data, 'result': False }
session_url = "{api_url}/session".format(api_url=CONST_DEFAULT_API)
session_post_data = {
"sapiToken": data['ssotoken'],
"deviceType": "PC",
"deviceModel": DEFAULT_BROWSER_NAME,
"osVersion": '{name} {version}'.format(name=DEFAULT_OS_NAME, version=DEFAULT_OS_VERSION),
"deviceSerial": profile_settings['devicekey'],
"appVersion": DEFAULT_BROWSER_VERSION,
"brand": "cds"
}
headers = {'Content-Type': 'application/json;charset=UTF-8'}
download = api_download(url=session_url, type='post', headers=headers, data=session_post_data, json_data=True, return_json=True, allow_redirects=False)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(data, 'token'):
return { 'code': code, 'data': data, 'result': False }
profile_settings['session_token'] = data['token']
save_profile(profile_id=1, profile=profile_settings)
return { 'code': code, 'data': data, 'result': True }
def api_login():
creds = get_credentials()
username = creds['username']
password = creds['password']
query = "UPDATE `vars` SET `cookies`='' WHERE profile_id={profile_id}".format(
profile_id=1)
query_settings(query=query,
return_result=False,
return_insert=False,
commit=True)
profile_settings = load_profile(profile_id=1)
if len(profile_settings['devicekey']) == 0:
devicekey = ''.join(
random.choice(string.ascii_uppercase + string.ascii_lowercase +
string.digits) for _ in range(64))
query = "UPDATE `vars` SET `devicekey`='{devicekey}' WHERE profile_id={profile_id}".format(
devicekey=devicekey, profile_id=1)
query_settings(query=query,
return_result=False,
return_insert=False,
commit=True)
session_url = '{api_url}/USER/SESSIONS/'.format(
api_url=profile_settings['api_url'])
email_or_pin = settings.getBool(key='email_instead_of_customer')
if email_or_pin:
session_post_data = {
"credentialsExtAuth": {
'credentials': {
'loginType': 'UsernamePassword',
'username': username,
'password': password,
'appId': 'KPN',
},
'remember': 'Y',
'deviceInfo': {
'deviceId': profile_settings['devicekey'],
'deviceIdType': 'DEVICEID',
'deviceType': 'PCTV',
'deviceVendor': profile_settings['browser_name'],
'deviceModel': profile_settings['browser_version'],
'deviceFirmVersion': profile_settings['os_name'],
'appVersion': profile_settings['os_version']
}
},
}
else:
session_post_data = {
"credentialsStdAuth": {
'username': username,
'password': password,
'remember': 'Y',
'deviceRegistrationData': {
'deviceId': profile_settings['devicekey'],
'accountDeviceIdType': 'DEVICEID',
'deviceType': 'PCTV',
'vendor': profile_settings['browser_name'],
'model': profile_settings['browser_version'],
'deviceFirmVersion': profile_settings['os_name'],
'appVersion': profile_settings['os_version']
}
},
}
download = api_download(url=session_url,
type='post',
headers=None,
data=session_post_data,
json_data=True,
return_json=True)
data = download['data']
code = download['code']
if not code or not code == 200 or not data or not check_key(
data, 'resultCode') or not data['resultCode'] == 'OK':
return {'code': code, 'data': data, 'result': False}
return {'code': code, 'data': data, 'result': True}
