def service():
alerts = userdata.get('alerts', [])
if not alerts:
return
now = arrow.now()
notify = []
_alerts = []
for id in alerts:
asset = api.event(id)
start = arrow.get(asset.get('preCheckTime', asset['transmissionTime']))
#If we are streaming and started less than 10 minutes ago
if asset.get('isStreaming', False) and (now - start).total_seconds() <= 60*10:
notify.append(asset)
elif start > now:
_alerts.append(id)
userdata.set('alerts', _alerts)
for asset in notify:
if not gui.yes_no(_(_.EVENT_STARTED, event=asset['title']), yeslabel=_.WATCH, nolabel=_.CLOSE):
continue
with signals.throwable():
start_from = 1
start = arrow.get(asset['transmissionTime'])
if start < now and 'preCheckTime' in asset:
precheck = arrow.get(asset['preCheckTime'])
if precheck < start:
start_from = (start - precheck).seconds
play(id=asset['id'], start_from=start_from, play_type=settings.getEnum('live_play_type', LIVE_PLAY_TYPES, default=FROM_CHOOSE))
def search(query=None, page=1, **kwargs):
page = int(page)
if not query:
query = gui.input(_.SEARCH, default=userdata.get('search', '')).strip()
if not query:
return
userdata.set('search', query)
data = api.filter_media('keyword', query, page=page)
total_pages = int(data['paginator']['total_pages'])
folder = plugin.Folder(title=_(_.SEARCH_FOR, query=query, page=page, total_pages=total_pages))
for row in data['data']:
item = _process_media(row)
folder.add_items([item])
if total_pages > page:
folder.add_item(
label = _(_.NEXT_PAGE, next_page=page+1),
path = plugin.url_for(search, query=query, page=page+1),
)
return folder
def _select_profile():
profiles = api.profiles()
profiles.append({'id': None, 'name': _.NO_PROFILE})
index = gui.select(_.SELECT_PROFILE, options=[p['name'] for p in profiles])
if index < 0:
return
userdata.set('profile', profiles[index]['id'])
def alert(asset, title, **kwargs):
alerts = userdata.get('alerts', [])
if asset not in alerts:
alerts.append(asset)
gui.notification(title, heading=_.REMINDER_SET)
else:
alerts.remove(asset)
gui.notification(title, heading=_.REMINDER_REMOVED)
userdata.set('alerts', alerts)
gui.refresh()
def alert(asset, title, image):
alerts = userdata.get('alerts', [])
if asset not in alerts:
alerts.append(asset)
gui.notification(_.REMINDER_SET, heading=title, icon=image)
else:
alerts.remove(asset)
gui.notification(_.REMINDER_REMOVED, heading=title, icon=image)
userdata.set('alerts', alerts)
gui.refresh()
def login(**kwargs):
username = gui.input(_.ASK_USERNAME, default=userdata.get('username', '')).strip()
if not username:
return
userdata.set('username', username)
password = gui.input(_.ASK_PASSWORD, hide_input=True).strip()
if not password:
return
api.login(username=username, password=password)
gui.refresh()
def start():
restart_queued = False
while not monitor.waitForAbort(2):
forced = ADDON_DEV or xbmc.getInfoLabel(
'Skin.String({})'.format(ADDON_ID)) == FORCE_RUN_FLAG
if forced or (settings.getBool('auto_merge', True)
and time.time() - userdata.get('last_run', 0) >
settings.getInt('reload_time_mins', 10) * 60):
xbmc.executebuiltin('Skin.SetString({},{})'.format(
ADDON_ID, FORCE_RUN_FLAG))
try:
run_merge([Source.PLAYLIST, Source.EPG])
except Exception as e:
result = False
log.exception(e)
else:
result = True
userdata.set('last_run', int(time.time()))
xbmc.executebuiltin('Skin.SetString({},)'.format(ADDON_ID))
if result:
restart_queued = True
if forced:
gui.notification(_.MERGE_COMPLETE)
elif forced:
gui.exception()
if restart_queued and (
forced or
(settings.getBool('restart_pvr', False)
and not xbmc.getCondVisibility('Pvr.IsPlayingTv')
and not xbmc.getCondVisibility('Pvr.IsPlayingRadio'))):
restart_queued = False
xbmc.executeJSONRPC(
'{{"jsonrpc":"2.0","id":1,"method":"Addons.SetAddonEnabled","params":{{"addonid":"{}","enabled":false}}}}'
.format(IPTV_SIMPLE_ID))
monitor.waitForAbort(2)
xbmc.executeJSONRPC(
'{{"jsonrpc":"2.0","id":1,"method":"Addons.SetAddonEnabled","params":{{"addonid":"{}","enabled":true}}}}'
.format(IPTV_SIMPLE_ID))
if ADDON_DEV:
break
def login(self, username, password):
device_id = hashlib.md5(username).hexdigest()
data = {
"deviceDetails": "test",
"deviceID": device_id,
"deviceIP": DEVICE_IP,
"password": password,
"username": username
}
resp = self._session.post(AUTH_URL, json=data)
data = resp.json()
if resp.status_code != 200 or 'sessiontoken' not in data:
raise APIError(_(_.LOGIN_ERROR, message=data.get('message')))
userdata.set('access_token', data['sessiontoken'])
userdata.set('device_id', device_id)
if settings.getBool('save_password', False):
userdata.set('pswd', password)
self._set_authentication()
data = self._session.get(SUBSCRIPTIONS_URL.format(data['profileId'])).json()
userdata.set('subscriptions', data['onlineSubscriptions'])
def login():
username = gui.input(_.ASK_USERNAME, default=userdata.get('username',
'')).strip()
if not username:
return
userdata.set('username', username)
password = gui.input(_.ASK_PASSWORD).strip()
if not password:
return
api.login(username=username, password=password)
_select_profile()
gui.refresh()
def start():
monitor = xbmc.Monitor()
restart_required = False
while not monitor.waitForAbort(5):
forced = xbmc.getInfoLabel(
'Skin.String({})'.format(ADDON_ID)) == FORCE_RUN_FLAG
xbmc.executebuiltin('Skin.SetString({},)'.format(ADDON_ID))
if forced or time.time() - userdata.get(
'last_run', 0) > settings.getInt('reload_time_mins') * 60:
try:
run_merge()
except Exception as e:
result = False
log.exception(e)
else:
result = True
userdata.set('last_run', int(time.time()))
if result:
restart_required = settings.getBool('restart_pvr', False)
if forced:
gui.notification(_.MERGE_COMPLETE)
elif forced:
gui.exception()
if restart_required and not xbmc.getCondVisibility(
'Pvr.IsPlayingTv') and not xbmc.getCondVisibility(
'Pvr.IsPlayingRadio'):
restart_required = False
addon_id = PVR_ADDON_IDS[settings.getInt('unused_pvr_id')]
xbmc.executebuiltin('InstallAddon({})'.format(addon_id), True)
xbmc.executeJSONRPC(
'{{"jsonrpc":"2.0","id":1,"method":"Addons.SetAddonEnabled","params":{{"addonid":"{}","enabled":true}}}}'
.format(addon_id))
xbmc.executeJSONRPC(
'{{"jsonrpc":"2.0","id":1,"method":"Addons.SetAddonEnabled","params":{{"addonid":"{}","enabled":false}}}}'
.format(addon_id))
def login():
while not api.logged_in:
username = gui.input(_(L_ASK_USERNAME), default=userdata.get('username', '')).strip()
if not username:
break
userdata.set('username', username)
password = gui.input(_(L_ASK_PASSWORD), default=cache.get('password', '')).strip()
if not password:
break
cache.set('password', password, expires=60)
if api.login(username=username, password=password):
gui.refresh()
else:
gui.ok(_(L_LOGIN_ERROR))
cache.delete('password')
def login(self, username, password):
self.logout()
payload = {
'email': username,
'password': password,
'platform': 'google',
}
data = self._session.post('/v1/login/', data=payload).json()
if 'error' in data:
try:
msg = data['error']['message']['base'][0]
except:
msg = ''
raise APIError(_(_.LOGIN_ERROR, msg=msg))
userdata.set('token', data['message']['auth_token'])
self._set_authentication()
def dns4me_login(**kwargs):
username = gui.input('dns4me Username').strip()
if not username:
return
password = gui.input('dns4me Password', hide_input=True).strip()
if not password:
return
data = Session().post('https://dns4me.net/api/v2/get_apikey',
data={
'username': username,
'password': password
}).json()
if 'apikey' in data:
userdata.set('dns4me_key', data['apikey'])
else:
plugin.exception('Failed to login')
gui.refresh()
def service():
alerts = userdata.get('alerts', [])
if not alerts:
return
now = arrow.now()
_alerts = []
for id in alerts:
asset = api.event(id)
start = arrow.get(asset.get('preCheckTime', asset['transmissionTime']))
if asset.get('isStreaming', False):
if gui.yes_no(_(_.EVENT_STARTED, event=asset['title']),
yeslabel=_.WATCH,
nolabel=_.CLOSE):
play(id).play()
elif start > now or (now - start).seconds < SERVICE_TIME:
_alerts.append(id)
userdata.set('alerts', _alerts)
def login(self, username, password):
log('API: Login')
data = {'response_type': 'token', 'lang': 'eng'}
resp = self._session.get(LOGIN_URL, params=data)
soup = BeautifulSoup(resp.text, 'html.parser')
form = soup.find('form', id='new_signin')
for e in form.find_all('input'):
data[e.attrs['name']] = e.attrs.get('value')
data.update({
'signin[email]': username,
'signin[password]': password,
})
resp = self._session.post(LOGIN_URL, data=data, allow_redirects=False)
access_token = resp.cookies.get('showmax_oauth')
if not access_token:
self.logout()
raise Error()
self.set_access_token(access_token)
data = self._session.get('user/current', params={'lang': 'eng'}).json()
if 'error_code' in data:
raise Error()
device_id = hashlib.sha1(username).hexdigest().upper()
userdata.set('device_id', device_id)
userdata.set('access_token', access_token)
userdata.set('user_id', data['user_id'])
def _oauth_token(self, data):
token_data = self._session.post(
'https://auth.kayosports.com.au/oauth/token', json=data).json()
if 'error' in token_data:
raise APIError(
_(_.LOGIN_ERROR, msg=token_data.get('error_description')))
account_status = None
try:
b64_string = token_data['access_token'].split('.')[1]
b64_string += "=" * ((4 - len(b64_string) % 4) % 4) #fix padding
data = json.loads(b64decode(b64_string))
account_status = data['https://kayosports.com.au/status'][
'account_status']
except:
log.debug('Failed to get account status')
if account_status and account_status != 'ACTIVE_SUBSCRIPTION':
raise APIError(_.INVALID_SUBSCRIPTION)
userdata.set('access_token', token_data['access_token'])
userdata.set('expires', int(time() + token_data['expires_in'] - 15))
if 'refresh_token' in token_data:
userdata.set('refresh_token', token_data['refresh_token'])
self._set_authentication()
def _renew_token(self):
password = userdata.get('pswd')
if password:
self.login(userdata.get('username'), password)
return
data = {
"deviceID": userdata.get('device_id'),
"deviceIP": DEVICE_IP,
"sessionToken": userdata.get('access_token'),
}
resp = self._session.post(RENEW_URL, json=data)
data = resp.json()
if resp.status_code != 200 or 'sessiontoken' not in data:
raise APIError(_(_.RENEW_TOKEN_ERROR, message=data.get('message')))
userdata.set('access_token', data['sessiontoken'])
self._set_authentication()
def search():
query = gui.input(_(L_SEARCH), default=userdata.get('search', '')).strip()
if not query:
return
userdata.set('search', query)
@cache.cached(LIST_EXPIRY)
def get_results(query):
folder = plugin.Folder(title=_(L_SEARCH_FOR, query=query))
rows = api.search(query)
folder.add_items(_parse_rows(rows))
if not folder.items:
folder.add_item(
label = _(L_NO_RESULTS, label=True),
is_folder = False,
)
return folder
return get_results(query)
def search(query=None, start=0, **kwargs):
start = int(start)
if not query:
query = gui.input(_.SEARCH, default=userdata.get('search', '')).strip()
if not query:
return
userdata.set('search', query)
folder = plugin.Folder(title=_(_.SEARCH_FOR, query=query))
data = api.content(text=query, start=start)
items = _process_content(data['data'])
folder.add_items(items)
if items and data['index'] < data['available']:
folder.add_item(
label = _(_.NEXT_PAGE, _bold=True),
path = plugin.url_for(search, query=query, start=data['index']),
)
return folder
def _oauth_token(self, data):
token_data = self._session.post('https://auth.kayosports.com.au/oauth/token', json=data).json()
if 'error' in token_data:
raise APIError(_(_.LOGIN_ERROR, msg=token_data.get('error_description')))
userdata.set('access_token', token_data['access_token'])
userdata.set('expires', int(time() + token_data['expires_in'] - 15))
if 'refresh_token' in token_data:
userdata.set('refresh_token', token_data['refresh_token'])
self._set_authentication()
