sdAPI.py

# -*- coding: utf-8 -*-
#
# Copyright (C) 2016 Thomas Geppert [bluezed] - bluezed.apps@gmail.com
#
# This Program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This Program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this Program; see the file LICENSE.txt. If not, write to
# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
# http://www.gnu.org/copyleft/gpl.html
#

import datetime
import requests

import xbmcgui
from utils import *
from strings import *

MAIN_URL = 'https://json.schedulesdirect.org/20141201'


class SdAPI(object):

 def __init__(self, user=get_setting('sd.username'), passw=get_setting('sd.password')):
 agent = "KODI-%s" % (ADDON.getAddonInfo('id'))
 self._headers = {'User-agent': agent}
 xbmc.log("[%s] SD-Header set to: %s" % (ADDON.getAddonInfo('id'), self._headers),
 xbmc.LOGDEBUG)

 self._main_url = MAIN_URL
 self._user = user
 self.logged_in = False
 self.changes_remaining = 0
 self.max_lineups = 0
 self.lineups = []
 if self._main_url and self._user and passw:
 self._pass = passw # Needs to be SHA1-Hex!
 self._get_token()
 if self.logged_in:
 self._get_status()
 else:
 raise SourceException('SD-Data not configured!')

 def _get_token(self):
 if 'token' in self._headers:
 del self._headers['token']
 resp = self._post('token', {"password": self._pass, "username": self._user})
 if 'code' in resp and int(resp['code']) != 0:
 xbmc.log("[%s] Error trying to log in: %s" % (ADDON.getAddonInfo('id'), resp['message']),
 xbmc.LOGDEBUG)
 xbmcgui.Dialog().ok(ADDON.getAddonInfo('name'), 'Error trying to log into SchedulesDirect:', resp['message'])
 self.logged_in = False
 elif 'token' in resp:
 xbmc.log("[%s] SD-Token received: %s" % (ADDON.getAddonInfo('id'), resp['token']),
 xbmc.LOGDEBUG)
 self._headers['token'] = resp['token']
 self.logged_in = True

 def _get_status(self):
 status = self._get('status')
 if 'account' in status and 'maxLineups' in status['account']:
 self.max_lineups = int(status['account']['maxLineups'])
 if 'lineups' in status:
 self.lineups = []
 for lineup in status['lineups']:
 self.lineups.append(lineup['lineup'])

 @staticmethod
 def _check_resp(resp):
 if resp.status_code == requests.codes.ok:
 info = (resp.text[:1000] + '..') if len(resp.text) > 1000 else resp.text
 xbmc.log("[%s] Reply from SD: %s - %s" %
 (ADDON.getAddonInfo('id'), resp.status_code, info), xbmc.LOGDEBUG)
 return True
 else:
 message = ''
 try:
 info = resp.json()
 if 'message' in info:
 message = info['message']
 except ValueError:
 message = resp.text

 xbmcgui.Dialog().ok(ADDON.getAddonInfo('name'), 'SchedulesDirect server reply:', message)
 xbmc.log("[%s] SD-Server response: %s - %s" %
 (ADDON.getAddonInfo('id'), resp.status_code, resp.text), xbmc.LOGDEBUG)
 return False

 def _get(self, path):
 url = MAIN_URL + "/" + path
 xbmc.log('[%s] GET request: %s' % (ADDON.getAddonInfo('id'), url), xbmc.LOGDEBUG)
 resp = requests.get(url, headers=self._headers)
 if self._check_resp(resp):
 return resp.json()
 else:
 return []

 def _put(self, path):
 url = MAIN_URL + "/" + path
 xbmc.log('[%s] PUT request: %s' % (ADDON.getAddonInfo('id'), url), xbmc.LOGDEBUG)
 resp = requests.put(url, headers=self._headers)
 if self._check_resp(resp):
 return resp.json()
 else:
 return []

 def _post(self, path, post_data=None):
 url = MAIN_URL + "/" + path
 data = ""
 if post_data:
 data = json.dumps(post_data)
 info = (data[:1000] + '..') if len(data) > 1000 else data
 xbmc.log('[%s] POST request: %s - data: %s' % (ADDON.getAddonInfo('id'), url, info),
 xbmc.LOGDEBUG)
 resp = requests.post(url, headers=self._headers, data=data)
 if self._check_resp(resp):
 return resp.json()
 else:
 return []

 def _delete(self, path):
 url = MAIN_URL + "/" + path
 xbmc.log('[%s] DELETE request: %s' % (ADDON.getAddonInfo('id'), url),
 xbmc.LOGDEBUG)
 resp = requests.delete(url, headers=self._headers)
 if self._check_resp(resp):
 return resp.json()
 else:
 return []

 def get_user_lineups(self):
 data = self._get('lineups')
 lineups = []
 self.lineups = []
 if "lineups" in data:
 for lineup in data['lineups']:
 lineups.append(lineup)
 self.lineups.append(lineup['lineup'])
 return lineups

 def get_countries(self):
 data = self._get('available/COUNTRIES')
 countries = []
 for _, country_list in data.iteritems():
 for country in country_list:
 countries.append(country)
 return countries

 def get_lineups(self, country, postcode):
 data = self._get('headends?country=%s&postalcode=%s' % (country, postcode))
 lineups = []
 for item in data:
 if "lineups" in item:
 for lineup in item['lineups']:
 lineups.append(lineup)
 return lineups

 def get_stations(self, lineup):
 data = self._get('lineups/%s' % lineup)
 stations = []
 if 'stations' in data:
 for station in data['stations']:
 logo = ''
 if 'logo' in station and 'URL' in station['logo']:
 logo = station['logo']['URL']
 logo_type = int(ADDON.getSetting('logos.source'))
 if logo_type == 1:
 logo = "%s%s.png" % (ADDON.getSetting('logos.folder'),station['name'])
 elif logo_type == 2:
 url = ADDON.getSetting('logos.url').rstrip('/')
 logo = "%s/%s.png" % (url,station['name'].replace(' ','%20'))
 channel = Channel(station['stationID'], station['name'], lineup, logo)
 stations.append(channel)
 return stations

 def save_lineup(self, lineup):
 resp = self._put('lineups/%s' % lineup)
 if "changesRemaining" in resp:
 self.changes_remaining = int(resp["changesRemaining"])
 if "response" in resp and resp["response"] == "OK":
 self.lineups.append(lineup)
 return True
 else:
 return False

 def delete_lineup(self, lineup):
 xbmc.log('[%s] Removing lineup "%s" form current lineups: %s' %
 (ADDON.getAddonInfo('id'), str(lineup), str(self.lineups)), xbmc.LOGDEBUG)
 resp = self._delete('lineups/%s' % lineup)
 if "changesRemaining" in resp:
 self.changes_remaining = int(resp["changesRemaining"])
 if "response" in resp and resp["response"] == "OK":
 self.lineups.remove(lineup)
 return True
 else:
 return False

 def get_schedules(self, stations, date, progress_callback):
 req_data = []
 dates = [date.strftime('%Y-%m-%d')]
 date2 = date
 for d in range(1, int(get_setting('sd.range'))):
 date2 = date2 + datetime.timedelta(days=1)
 dates.append(date2.strftime('%Y-%m-%d'))
 for s in stations:
 req_data.append({'stationID': s, 'date': dates})

 resp = self._post('schedules', req_data)

 if progress_callback:
 if not progress_callback(10):
 raise SourceException()

 prg_list = []
 schedule = []
 for record in resp:
 if "stationID" in record:
 station_id = record['stationID']
 else:
 continue

 if "programs" in record:
 for program in record['programs']:
 p_id = program['programID']
 start = program['airDateTime']
 dur = program['duration']
 prg_list.append(p_id)
 schedule.append({'station_id': station_id, 'p_id': p_id, 'start': start,
 'dur': dur, 'title': '', 'desc': '', 'logo': ''})

 prg_count = len(prg_list)
 if prg_count < 3000:
 xbmc.log("[%s] Number of programs requested: %d" %
 (ADDON.getAddonInfo('id'), prg_count), xbmc.LOGDEBUG)
 p_resp = self._post('programs', prg_list)
 if progress_callback:
 if not progress_callback(75):
 raise SourceException()
 else:
 xbmc.log("[%s] Number of programs requested: %d... Requesting batches of 3000" %
 (ADDON.getAddonInfo('id'), prg_count), xbmc.LOGDEBUG)
 # Deal with more data requestes
 p_resp = []
 batches = list(grouper(3000, prg_list))
 step = (75-10) / len(batches)
 for ctr, batch in enumerate(batches):
 batch = filter(None, batch)
 xbmc.log("[%s] Requesting batch %d with %d items" %
 (ADDON.getAddonInfo('id'), ctr+1, len(batch)), xbmc.LOGDEBUG)
 p_resp += self._post('programs', batch)
 if progress_callback:
 if not progress_callback(10 + (ctr * step)):
 raise SourceException()

 elements_parsed = 0
 for prg_data in p_resp:
 if 'programID' in prg_data:
 prg_id = prg_data['programID']
 else:
 continue

 # find the idx in the schedule
 idx = []
 for i, s in enumerate(schedule):
 if s['p_id'] == prg_id:
 idx.append(i)

 title = ''
 if 'titles' in prg_data and len(prg_data['titles']) > 0:
 if 'title120' in prg_data['titles'][0]:
 title = prg_data['titles'][0]['title120']

 desc = ''
 if 'episodeTitle150' in prg_data:
 desc = prg_data['episodeTitle150'] + ' - '

 if 'descriptions' in prg_data:
 tmp_d = None
 if 'description1000' in prg_data['descriptions']:
 tmp_d = prg_data['descriptions']['description1000']
 elif 'description100' in prg_data['descriptions']:
 tmp_d = prg_data['descriptions']['description100']

 if tmp_d and len(tmp_d) > 0 and 'description' in tmp_d[0]:
 desc += tmp_d[0]['description']

 for i in idx:
 schedule[i]['title'] = title
 schedule[i]['desc'] = desc

 elements_parsed += 1
 if progress_callback and elements_parsed % 100 == 0:
 if not progress_callback(100.0 / prg_count * elements_parsed):
 raise SourceException()
 return schedule