def getRecordByNumber(self, request_number):
name = ''
imageBMP = None
if isinstance(self.__phonebook, dict):
for item in self.__phonebook:
for number in self.__phonebook[item]['numbers']:
if self.__phoneBookFacade.compareNumbers(
number, request_number, ccode=self.Mon.cCode):
tools.writeLog(
'Match an entry in database for %s: %s' %
(request_number, item), xbmc.LOGNOTICE)
name = item
fname = os.path.join(
__ImageCache__,
hashlib.md5(item.encode('utf-8')).hexdigest() +
'.jpg')
if os.path.isfile(fname):
tools.writeLog(
'Load image from cache: %s' %
(os.path.basename(fname)), xbmc.LOGNOTICE)
imageBMP = fname
break
return {'name': name, 'imageBMP': imageBMP}
def handleIncomingCall(self, line):
if line.number_called in self.Mon.exnum_list:
self.__hide = True
return
self.handlePlayerProps('incoming')
if len(line.number_caller) > 0:
caller_num = line.number_caller
tools.writeLog(
'trying to resolve name from incoming number %s' %
(caller_num), xbmc.LOGNOTICE)
record = self.getRecordByNumber(caller_num)
name = record['name']
icon = __IconOk__ if record['imageBMP'] == '' else record[
'imageBMP']
if not name:
name = self.getNameByKlickTel(caller_num)
if name:
icon = __IconKlickTel__
else:
icon = __IconUnknown__
name = __LS__(30012)
else:
name = __LS__(30012)
caller_num = __LS__(30016)
icon = __IconUnknown__
tools.writeLog('Incoming call from %s (%s)' % (name, caller_num),
xbmc.LOGNOTICE)
tools.notify(__LS__(30010),
__LS__(30011) % (name, caller_num), icon,
self.Mon.dispMsgTime)
def calc_boundaries(direction):
sheet_m = int(
xbmcgui.Window(10000).getProperty('calendar_month')) + direction
sheet_y = int(xbmcgui.Window(10000).getProperty('calendar_year'))
if sheet_m < 1:
sheet_m = 12
sheet_y -= 1
elif sheet_m > 12:
sheet_m = 1
sheet_y += 1
if sheet_y == datetime.today().year:
if sheet_m < datetime.today().month or sheet_m > datetime.today(
).month + tools.getAddonSetting('timemax', sType=tools.NUM):
tools.writeLog('prev/next month outside boundary')
return
else:
if sheet_m + 12 > datetime.today().month + tools.getAddonSetting(
'timemax', sType=tools.NUM):
tools.writeLog('prev/next month outside boundary')
return
xbmcgui.Window(10000).setProperty('calendar_month', str(sheet_m))
xbmcgui.Window(10000).setProperty('calendar_year', str(sheet_y))
_header = '%s %s' % (__LS__(30119 + sheet_m), sheet_y)
xbmcgui.Window(10000).setProperty('calendar_header', _header)
def handleIncomingCall(self, line):
if line.number_called in self.Mon.exnum_list:
self.__hide = True
return
self.handlePlayerProps('incoming')
if len(line.number_caller) > 0:
caller_num = line.number_caller
tools.writeLog(
'trying to resolve name from incoming number %s' %
(tools.mask(caller_num)), xbmc.LOGNOTICE)
record = self.getRecordByNumber(caller_num)
name = record['name']
icon = ICON_OK if record['imageBMP'] == '' else record['imageBMP']
if not name:
name = LOC(30012)
icon = ICON_UNKNOWN
else:
caller_num = LOC(30016)
name = LOC(30012)
icon = ICON_UNKNOWN
tools.writeLog(
'Incoming call from %s (%s)' %
(tools.mask(name), tools.mask(caller_num)), xbmc.LOGNOTICE)
tools.notify(LOC(30010),
LOC(30011) % (name, caller_num),
icon,
self.Mon.dispMsgTime,
deactivateSS=True)
def prepareForAddon(cls,
event,
timebase=datetime.now(),
optTimeStamps=True):
_ts = parser.parse(event['start'].get('dateTime',
event['start'].get('date', '')))
_end = parser.parse(event['end'].get('dateTime',
event['end'].get('date', '')))
_tdelta = relativedelta.relativedelta(_end.date(), _ts.date())
if event.get('allday', 0) > 0:
if _tdelta.months == 0 and _tdelta.weeks == 0 and _tdelta.days == 0:
event.update({'range': ''})
elif _tdelta.months == 0 and _tdelta.weeks == 0 and _tdelta.days == 1:
event.update({'range': __LS__(30111)})
elif _tdelta.months == 0 and _tdelta.weeks == 0:
event.update({'range': __LS__(30112) % (_tdelta.days)})
elif _tdelta.months == 0 and _tdelta.weeks == 1:
event.update({'range': __LS__(30113)})
elif _tdelta.months == 0 and _tdelta.weeks > 0:
event.update({'range': __LS__(30114) % (_tdelta.weeks)})
elif _tdelta.months == 1:
event.update({'range': __LS__(30115)})
elif _tdelta.months > 1:
event.update({'range': __LS__(30116) % (_tdelta.months)})
else:
event.update({'range': __LS__(30117)})
else:
if _ts != _end:
event.update({
'range':
_ts.strftime('%H:%M') + ' - ' + _end.strftime('%H:%M')
})
else:
event.update({'range': _ts.strftime('%H:%M')})
if optTimeStamps:
t.writeLog('calculate additional timestamps')
_tdelta = relativedelta.relativedelta(_ts.date(), timebase.date())
if _tdelta.months == 0:
if _tdelta.days == 0: ats = __LS__(30139)
elif _tdelta.days == 1: ats = __LS__(30140)
elif _tdelta.days == 2: ats = __LS__(30141)
elif 3 <= _tdelta.days <= 6:
ats = __LS__(30142) % (_tdelta.days)
elif _tdelta.weeks == 1:
ats = __LS__(30143)
elif _tdelta.weeks > 1:
ats = __LS__(30144) % (_tdelta.weeks)
else:
ats = __LS__(30117)
elif _tdelta.months == 1:
ats = __LS__(30146)
else:
ats = __LS__(30147) % (_tdelta.months)
event.update({'timestamps': ats})
return event
def getRecordByNumber(self, request_number):
name = ''
imageBMP = None
if isinstance(self.__phonebook, dict):
for item in self.__phonebook:
for number in self.__phonebook[item]['numbers']:
if self.__phoneBookFacade.compareNumbers(
number, request_number, ccode=self.Mon.cCode):
tools.writeLog(
'Match an entry in database for %s: %s' %
(tools.mask(request_number), tools.mask(item)),
xbmc.LOGNOTICE)
name = item
fname = os.path.join(
IMAGECACHE,
re.sub('\D', '', number.replace('+', '00')) +
'.jpg')
if os.path.isfile(fname):
tools.writeLog('Load image from cache',
xbmc.LOGNOTICE)
imageBMP = fname
break
return {'name': name, 'imageBMP': imageBMP}
def setPowerOffEvent():
# Create notification file
try:
open(POWER_OFF_FILE, 'w').close()
return True
except IOError:
tools.writeLog('Unable to create power off file %s' %
POWER_OFF_FILE,
level=xbmc.LOGERROR)
return False
def getNameByKlickTel(self, request_number):
if self.Mon.useKlickTelReverse:
if self.__klicktel is None:
self.__klicktel = KlickTel.KlickTelReverseSearch()
try:
return self.__klicktel.search(request_number)
except Exception as e:
tools.writeLog(str(e), level=xbmc.LOGERROR)
return False
def getNameByKlickTel(self, request_number):
if self.Mon.useKlickTelReverse:
if self.__klicktel is None:
self.__klicktel = KlickTel.KlickTelReverseSearch()
try:
return self.__klicktel.search(request_number)
except Exception, e:
tools.writeLog('Error at line %s' %
(sys.exc_info()[-1].tb_lineno))
tools.writeLog(e.message, level=xbmc.LOGERROR)
def checkOutdatedRecordings(self, mode):
nodedata = self.readStatusXML('title')
for item in nodedata:
if not item in self.__recTitles:
self.__recTitles.append(item)
tools.writeLog('Recording of "%s" is active' % (item))
for item in self.__recTitles:
if not item in nodedata:
self.__recTitles.remove(item)
tools.writeLog('Recording of "%s" has finished' % (item))
if mode is None:
self.deliverMail(__LS__(30047) % (release.hostname, item))
def getPowerOffEvent(remove=True):
if os.path.isfile(POWER_OFF_FILE):
if remove:
try:
os.remove(POWER_OFF_FILE)
except OSError:
tools.writeLog('Unable to remove power off file %s' %
POWER_OFF_FILE,
level=xbmc.LOGERROR)
return False
return True
return False # No event
def get_calendarIdFromSetup(self, setting):
calId = []
_cals = t.getAddonSetting(setting).split(', ')
if len(_cals) == 1 and _cals[0] == 'primary':
calId.append('primary')
else:
cals = self.get_calendars()
for cal in cals:
if cal.get('summaryOverride', cal.get('summary',
'primary')) in _cals:
calId.append(cal.get('id'))
t.writeLog('getting cal ids from setup: %s' % (', '.join(calId)))
return calId
def readStatusXML(self, xmlnode):
nodedata = []
try:
_xml = minidom.parseString(self.getPvrStatusXML())
nodes = _xml.getElementsByTagName(xmlnode)
for node in nodes:
if node: nodedata.append(node.childNodes[0].data)
return nodedata
except TypeError:
tools.writeLog("Could not read XML tree from %s" % self.__server,
xbmc.LOGERROR)
return nodedata
def connect(self, notify=False):
if self.__s is not None:
self.__s.close()
self.__s = None
try:
self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__s.settimeout(30)
self.__s.connect((self.Mon.server, LISTENPORT))
except socket.error as e:
if notify:
tools.notify(__LS__(30030),
__LS__(30031) % (self.Mon.server, LISTENPORT),
__IconError__)
tools.writeLog('Could not connect to %s:%s' %
(self.Mon.server, LISTENPORT),
level=xbmc.LOGERROR)
tools.writeLog('%s' % (e), level=xbmc.LOGERROR)
return False
except Exception as e:
tools.writeLog('%s' % (e), level=xbmc.LOGERROR)
return False
else:
tools.writeLog(
'Connected, listen to %s on port %s' %
(self.Mon.server, LISTENPORT), xbmc.LOGNOTICE)
self.__s.settimeout(0.2)
return True
def getPhonebook(self):
if self.__phoneBookFacade is None:
self.__phoneBookFacade = PhoneBookFacade(imagepath=__ImageCache__)
setting_keys = self.__phoneBookFacade.get_setting_keys()
for key in setting_keys:
setting_keys[key] = __addon__.getSetting(key)
self.__phoneBookFacade.set_settings(setting_keys)
if self.__phonebook is None:
try:
self.__phonebook = self.__phoneBookFacade.getPhonebook()
tools.writeLog(
'%s entries from %s loaded, %s images cached' %
(len(self.__phonebook), self.Mon.server,
self.__phoneBookFacade.imagecount()), xbmc.LOGNOTICE)
except self.__phoneBookFacade.HostUnreachableException:
tools.writeLog('Host %s unreachable' % (self.Mon.server),
level=xbmc.LOGERROR)
tools.notify(__LS__(30030),
__LS__(30031) % (self.Mon.server, LISTENPORT),
__IconError__)
except self.__phoneBookFacade.LoginFailedException:
tools.writeLog('Login failed. Check username/password',
level=xbmc.LOGERROR)
tools.notify(__LS__(30033), __LS__(30034), __IconError__)
except self.__phoneBookFacade.InternalServerErrorException:
tools.writeLog('Internal server error', level=xbmc.LOGERROR)
tools.notify(__LS__(30035), __LS__(30036), __IconError__)
def setWakeup(self):
if xbmc.getCondVisibility('Player.Playing'):
tools.writeLog('Stopping Player')
xbmc.Player().stop()
_flags = self.calcNextSched()
tools.writeLog(
'Instruct the system to shut down using %s' %
('Application' if self.__shutdown == 0 else 'OS'), xbmc.LOGNOTICE)
tools.writeLog('Wake-Up Unix Time: %s' % (self.__wakeUpUT),
xbmc.LOGNOTICE)
tools.writeLog(
'Flags on resume points will be later {0:05b}'.format(_flags))
os.system(
'%s%s %s %s' %
(self.__sudo, SHUTDOWN_CMD, self.__wakeUpUT, self.__shutdown))
if self.__shutdown == 0: xbmc.shutdown()
xbmc.sleep(1000)
# If we suspend instead of poweroff the system, we need the flags to control the main loop of the service.
# On suspend we have to resume the service on resume points instead of start on poweron/login.
# additional we set the resume flag in calcNextSched if necessary
return _flags
def get_calendars(self):
if not os.path.exists(
self.TEMP_STORAGE_CALENDARS) or not t.lastmodified(
self.TEMP_STORAGE_CALENDARS, 60):
t.writeLog('establish online connection for getting calendars')
self.establish()
cal_list = self.service.calendarList().list().execute()
cals = cal_list.get('items', [])
with open(self.TEMP_STORAGE_CALENDARS, 'w') as filehandle:
json.dump(cals, filehandle)
return cals
else:
t.writeLog('getting calendars from local storage')
with open(self.TEMP_STORAGE_CALENDARS, 'r') as filehandle:
return json.load(filehandle)
def getPvrStatusXML(self):
_attempts = self.__maxattempts
if not self.hasPVR:
tools.writeLog('No HTS PVR client installed or inactive',
level=xbmc.LOGERROR)
tools.Notify().notify(__LS__(30030),
__LS__(30032),
icon=xbmcgui.NOTIFICATION_ERROR)
return None
else:
while self.hasPVR and _attempts > 0:
# try DigestAuth as first, as this is the default auth on TVH > 3.9
try:
conn = requests.get('%s:%s/status.xml' %
(self.__server, self.__port),
auth=requests.auth.HTTPDigestAuth(
self.__user, self.__pass))
conn.close()
if conn.status_code == 200:
tools.writeLog('Getting status.xml (Digest Auth)')
return conn.content
else:
# try BasicAuth as older method
conn = requests.get('%s:%s/status.xml' %
(self.__server, self.__port),
auth=requests.auth.HTTPBasicAuth(
self.__user, self.__pass))
conn.close()
if conn.status_code == 200:
tools.writeLog('Getting status.xml (Basic Auth)')
return conn.content
if conn.status_code == 401:
tools.writeLog('Unauthorized access (401)')
break
except requests.ConnectionError:
_attempts -= 1
tools.writeLog('%s unreachable, remaining attempts: %s' %
(self.__server, _attempts))
xbmc.sleep(5000)
continue
tools.Notify().notify(__LS__(30030),
__LS__(30031),
icon=xbmcgui.NOTIFICATION_ERROR)
return None
def get_events(self,
storage,
timeMin,
timeMax,
maxResult=30,
calendars='primary'):
if not os.path.exists(storage) or not t.lastmodified(storage, 60):
t.writeLog('establish online connection for getting events')
self.establish()
events = []
for cal in calendars:
cal_events = self.service.events().list(
calendarId=cal,
timeMin=timeMin,
timeMax=timeMax,
maxResults=maxResult,
singleEvents=True,
orderBy='startTime').execute()
_evs = cal_events.get('items', [])
if _evs:
# set additional attributes
calColor = self.get_calendarBGcolorImage(cal)
for _ev in _evs:
_ts = parser.parse(_ev['start'].get(
'dateTime', _ev['start'].get('date',
''))).timetuple()
_ev.update({'timestamp': int(time.mktime(_ts))})
_ev.update({'icon': calColor})
gadget = _ev.get('gadget', None)
if gadget:
if gadget.get('preferences').get(
'goo.contactsEventType') == 'BIRTHDAY':
_ev.update({'specialicon': __cake__})
events.extend(_evs)
events.sort(key=operator.itemgetter('timestamp'))
with open(storage, 'w') as filehandle:
json.dump(events, filehandle)
else:
t.writeLog('getting events from local storage')
with open(storage, 'r') as filehandle:
events = json.load(filehandle)
return events
def connect(self, notify=False):
if self.__s is not None:
self.__s.close()
self.__s = None
try:
self.__s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.__s.settimeout(30)
self.__s.connect((self.Mon.server, LISTENPORT))
except socket.error, e:
if notify:
tools.notify(LOC(30030),
LOC(30031) % (self.Mon.server, LISTENPORT),
ICON_ERROR)
tools.writeLog('Could not connect to %s:%s' %
(self.Mon.server, LISTENPORT),
level=xbmc.LOGERROR)
tools.writeLog(e.message, level=xbmc.LOGERROR)
return False
def handleOutgoingCall(self, line):
if line.number_used in self.Mon.exnum_list:
self.__hide = True
return
if self.Mon.optShowOutgoing:
self.handlePlayerProps('outgoing')
record = self.getRecordByNumber(line.number_called)
name = __LS__(30012) if record['name'] == '' else record['name']
icon = __IconDefault__ if record['imageBMP'] == '' else record[
'imageBMP']
tools.notify(__LS__(30013),
__LS__(30014) % (name, line.number_called), icon)
tools.writeLog(
'Outgoing call from %s to %s' %
(line.number_used, line.number_called), xbmc.LOGNOTICE)
def switch(self, cmd, ain=None):
# Call an actor method
if self.__fbSID is None:
t.writeLog('Not logged in', level=xbmc.LOGERROR)
return
params = {
'switchcmd': cmd,
'sid': self.__fbSID,
}
if ain: params['ain'] = ain
response = self.session.get(self.base_url +
'/webservices/homeautoswitch.lua',
params=params,
verify=False)
response.raise_for_status()
xbmcgui.Window(10000).setProperty('fritzact.timestamp',
str(int(time())))
return response.text.strip()
def handleOutgoingCall(self, line):
if line.number_used in self.Mon.exnum_list:
self.__hide = True
return
if self.Mon.optShowOutgoing:
self.handlePlayerProps('outgoing')
record = self.getRecordByNumber(line.number_called)
name = LOC(30012) if record['name'] == '' else record['name']
icon = ICON_OK if record['imageBMP'] == '' else record['imageBMP']
tools.notify(LOC(30013),
LOC(30014) % (name, line.number_called),
icon,
deactivateSS=True)
tools.writeLog(
'Outgoing call from %s to %s' %
(tools.mask(line.number_used), tools.mask(line.number_called)),
xbmc.LOGNOTICE)
def updateAutoModeDialog(self):
if not self.__dialog_pb is None:
if self.__auto_mode_counter == 0:
self.disableScreensaver()
tools.writeLog('Display countdown dialog for %s secs' %
(self.__auto_mode_set))
if xbmc.getCondVisibility('VideoPlayer.isFullscreen'):
tools.writeLog(
'Countdown possibly invisible (fullscreen mode)')
tools.writeLog('Showing additional notification')
tools.Notify().notify(
__LS__(30010),
__LS__(30011) % (self.__auto_mode_set))
# actualize progressbar
if self.__auto_mode_counter < self.__auto_mode_set:
__percent = int(self.__auto_mode_counter * 100 /
self.__auto_mode_set)
self.__dialog_pb.update(
__percent, __LS__(30010),
__LS__(30011) %
(self.__auto_mode_set - self.__auto_mode_counter))
self.__auto_mode_counter += 1
if self.__auto_mode_counter == self.__auto_mode_set:
return True
return False
def start(self):
if self.connect(notify=True):
# MAIN SERVICE
while not xbmc.abortRequested:
# ToDo: investigate more from https://pymotw.com/2/select/index.html#module-select
# i.e check exception handling
try:
fbdata = self.__s.recv(512)
line = self.CallMonitorLine(fbdata)
{
'CALL': self.handleOutgoingCall,
'RING': self.handleIncomingCall,
'CONNECT': self.handleConnected,
'DISCONNECT': self.handleDisconnected
}.get(line.command)(line)
except socket.timeout:
pass
except socket.error, e:
tools.writeLog('No connection to %s, try to respawn' %
(self.Mon.server),
level=xbmc.LOGERROR)
tools.writeLog(e.message, level=xbmc.LOGERROR)
self.connect()
except IndexError:
tools.writeLog('Communication failure',
level=xbmc.LOGERROR)
self.connect()
except Exception, e:
tools.writeLog('Error at line %s' %
(sys.exc_info()[-1].tb_lineno))
tools.writeLog(e.message, level=xbmc.LOGERROR)
break
def countDown(cls, counter=5):
__bar = 0
__percent = 0
__counter = counter
__idleTime = xbmc.getGlobalIdleTime()
# deactivate screensaver (send key select)
if xbmc.getCondVisibility('System.ScreenSaverActive'):
query = {"method": "Input.Select"}
tools.jsonrpc(query)
if xbmc.getCondVisibility('VideoPlayer.isFullscreen'):
tools.writeLog('Countdown possibly invisible (fullscreen mode)')
tools.writeLog('Showing additional notification')
tools.Notify().notify(__LS__(30010), __LS__(30011) % (__counter))
# show countdown
tools.writeLog('Display countdown dialog for %s secs' % __counter)
pb = xbmcgui.DialogProgressBG()
pb.create(__LS__(30010), __LS__(30011) % __counter)
pb.update(__percent)
# actualize progressbar
while __bar <= __counter:
__percent = int(__bar * 100 / __counter)
pb.update(__percent, __LS__(30010),
__LS__(30011) % (__counter - __bar))
if __idleTime > xbmc.getGlobalIdleTime():
tools.writeLog('Countdown aborted by user',
level=xbmc.LOGNOTICE)
pb.close()
return True
xbmc.sleep(1000)
__idleTime += 1
__bar += 1
pb.close()
return False
def deliverMail(self, message):
if self.__notification:
try:
__port = {'None': 25, 'SSL/TLS': 465, 'STARTTLS': 587}
__s_msg = Message()
__s_msg.set_charset(self.__charset)
__s_msg.set_payload(message, charset=self.__charset)
__s_msg["Subject"] = __LS__(30046) % (release.hostname)
__s_msg["From"] = self.__smtpfrom
__s_msg["To"] = self.__smtpto
if self.__smtpenc == 'STARTTLS':
__s_conn = smtplib.SMTP(self.__smtpserver,
__port[self.__smtpenc])
__s_conn.ehlo()
__s_conn.starttls()
elif self.__smtpenc == 'SSL/TLS':
__s_conn = smtplib.SMTP_SSL(self.__smtpserver,
__port[self.__smtpenc])
__s_conn.ehlo()
else:
__s_conn = smtplib.SMTP(self.__smtpserver,
__port[self.__smtpenc])
__s_conn.login(self.__smtpuser, self.__smtppass)
__s_conn.sendmail(self.__smtpfrom, self.__smtpto,
__s_msg.as_string())
__s_conn.close()
tools.writeLog('Mail delivered to %s.' % (self.__smtpto),
level=xbmc.LOGINFO)
return True
except Exception as e:
tools.writeLog(
'Mail could not be delivered. Check your settings.',
level=xbmc.LOGERROR)
tools.writeLog(e)
return False
else:
tools.writeLog('"%s" completed, no Mail delivered.' % (message))
return True
def __init__(self):
self.getSettings()
self.base_url = self.__fbtls + self.__fbserver
self.session = requests.Session()
if self.__fbSID is None or (int(time()) - self.__lastLogin > 600):
t.writeLog(
'SID is none/last login more than 10 minutes ago, try to login'
)
sid = None
try:
response = self.session.get(self.base_url + '/login_sid.lua',
verify=False)
xml = ET.fromstring(response.text)
if xml.find('SID').text == "0000000000000000":
challenge = xml.find('Challenge').text
url = self.base_url + '/login_sid.lua'
response = self.session.get(url,
params={
"username":
self.__fbuser,
"response":
self.calculate_response(
challenge,
self.__fbpasswd),
},
verify=False)
xml = ET.fromstring(response.text)
if xml.find('SID').text == "0000000000000000":
blocktime = int(xml.find('BlockTime').text)
t.writeLog(
"Login failed, please wait %s seconds" %
(blocktime), xbmc.LOGERROR)
t.notifyOSD(__addonname__, __LS__(30012) % (blocktime))
else:
sid = xml.find('SID').text
except (requests.exceptions.ConnectionError, TypeError):
t.writeLog('FritzBox unreachable', level=xbmc.LOGERROR)
t.notifyOSD(__addonname__, __LS__(30010))
self.__fbSID = sid
self.__lastLogin = int(time())
__addon__.setSetting('SID', self.__fbSID)
__addon__.setSetting('lastLogin', str(self.__lastLogin))
def controller(mode=None, handle=None, content=None, eventId=None, actor=None):
now = datetime.utcnow().replace(hour=0, minute=0, second=0,
microsecond=0).isoformat() + 'Z'
timemax = (
datetime.utcnow().replace(hour=0, minute=0, second=0, microsecond=0) +
relativedelta.relativedelta(months=tools.getAddonSetting(
'timemax', sType=tools.NUM))).isoformat() + 'Z'
if mode == 'load_glotz_key':
glotz_apikey = tools.dialogFile(__LS__(30089))
if glotz_apikey != '':
tools.setAddonSetting('glotz_apikey', glotz_apikey)
tools.writeLog('API key for glotz.info successfull stored')
tools.Notify().notify(__LS__(30010), __LS__(30073))
elif mode == 'abort_reminders':
tools.writeLog('abort notification service by setup', xbmc.LOGNOTICE)
xbmcgui.Window(10000).setProperty('reminders', '0')
elif mode == 'getcontent':
googlecal = Calendar()
googlecal.build_sheet(handle,
TEMP_STORAGE_EVENTS,
content,
now,
timemax,
maxResult=30)
elif mode == 'getinfo' and eventId != '':
googlecal = Calendar()
events = eventId.strip(' ').split(' ')
_header = ''
_msg = ''
for event in events:
_ev = googlecal.get_event(event, TEMP_STORAGE_EVENTS)
_mev = googlecal.prepareForAddon(_ev, optTimeStamps=True)
_time = '' if _mev.get(
'range', '') == '' else '[B]%s[/B]: ' % (_mev.get('range'))
if actor and actor == 'eventlist':
_header = 'S%02iE%02i: %s' % (
_mev.get('season'), _mev.get('episode'), _mev.get('title'))
_msg = '%s' % (_mev.get('plot'))
else:
_header = '%s %s %s' % (__LS__(30109), __LS__(30145),
_mev.get('shortdate', ''))
_msg += '%s%s[CR]%s[CR][CR]' % (_time, _mev.get(
'summary', ''), _mev.get('description') or __LS__(30093))
tools.dialogOK(_header, _msg)
elif mode == 'prev':
calc_boundaries(-1)
elif mode == 'next':
calc_boundaries(1)
# this is the real controller bootstrap
elif mode == 'gui':
try:
Popup = xbmcgui.WindowXMLDialog(__xml__, __path__)
Popup.doModal()
del Popup
except RuntimeError as e:
raise FileNotFoundException('%s: %s' % (e.message, __xml__))
else:
pass
if __name__ == '__main__':
action = None
content = None
eventId = None
actor = None
_addonHandle = None
arguments = sys.argv
if len(arguments) > 1:
if arguments[0][0:6] == 'plugin': # calling as plugin path
_addonHandle = int(arguments[1])
arguments.pop(0)
arguments[1] = arguments[1][1:]
tools.writeLog('parameter hash: %s' % (str(arguments[1])),
xbmc.LOGNOTICE)
params = tools.ParamsToDict(arguments[1])
action = params.get('action', '')
content = params.get('content', '')
eventId = params.get('id', '')
actor = params.get('actor')
# call the controller of MVC
try:
if action is not None:
controller(mode=action,
handle=_addonHandle,
content=content,
eventId=eventId,
actor=actor)
else:
