def handler(self, *args):
nowtime = datetime.datetime.utcnow().timestamp()
source = request.args.get('source', default=self.fhdhr.device.epg.def_method, type=str)
epg_methods = self.fhdhr.device.epg.valid_epg_methods
if source not in epg_methods:
source = self.fhdhr.device.epg.def_method
origin_methods = self.fhdhr.origins.list_origins
channelslist = {}
unmatched_origins = {}
if not source:
return render_template('guide.html', request=request, session=session, fhdhr=self.fhdhr, channelslist=channelslist, epg_methods=epg_methods, source=source, origin_methods=origin_methods, unmatched_origins=unmatched_origins, list=list)
whatson_all = self.fhdhr.device.epg.whats_on_allchans(source)
sorted_channel_list = channel_sort([x for x in list(whatson_all.keys())])
for origin_name in origin_methods:
unmatched_origins[origin_name] = []
curr_origin = self.fhdhr.device.epg.get_epg_chan_unmatched(origin_name, source)
sorted_unmatched = channel_sort([x["number"] for x in curr_origin])
for channel_number in sorted_unmatched:
unmatched_origins[origin_name].append([x for x in curr_origin if x["number"] == channel_number][0])
for channel in sorted_channel_list:
channel_dict, channel_number = self.create_channeldict(source, origin_methods, epg_methods, whatson_all, nowtime, channel)
channelslist[channel_number] = channel_dict
return render_template('guide.html', request=request, session=session, fhdhr=self.fhdhr, channelslist=channelslist, epg_methods=epg_methods, source=source, origin_methods=origin_methods, unmatched_origins=unmatched_origins, list=list)
def get(self, *args):
origin = request.args.get('origin', default=self.fhdhr.device.epg.def_method, type=str)
origin_methods = self.fhdhr.origins.valid_origins
if origin not in origin_methods:
origin = origin_methods[0]
channelslist = {}
for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels(origin)]:
channel_obj = self.fhdhr.device.channels.get_channel_obj("id", fhdhr_id, origin)
channel_dict = channel_obj.dict.copy()
channel_dict["number"] = channel_obj.number
channel_dict["chan_thumbnail"] = channel_obj.thumbnail
channel_dict["m3u_url"] = channel_obj.api_m3u_url
channelslist[channel_dict["number"]] = channel_dict
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channelslist[channel])
return render_template('channels_editor.html', request=request, session=session, fhdhr=self.fhdhr, channelslist=sorted_chan_guide, origin=origin, origin_methods=origin_methods, list=list)
def get(self, *args):
base_url = request.url_root[:-1]
show = request.args.get('show', default="all", type=str)
channelslist = {}
for fhdhr_id in [
x["id"] for x in self.fhdhr.device.channels.get_channels()
]:
channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
if channel_obj.enabled or show == "found":
lineup_dict = channel_obj.lineup_dict
lineup_dict["URL"] = "%s%s" % (base_url, lineup_dict["URL"])
if show == "found" and channel_obj.enabled:
lineup_dict["Enabled"] = 1
elif show == "found" and not channel_obj.enabled:
lineup_dict["Enabled"] = 0
channelslist[channel_obj.number] = lineup_dict
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channelslist[channel])
lineup_json = json.dumps(sorted_chan_guide, indent=4)
return Response(status=200,
response=lineup_json,
mimetype='application/json')
def get_channel_lineup(self, origin_name, base_url, show):
chan_guide = []
channelslist = {}
for fhdhr_channel_id in self.plugin_utils.origins.origins_dict[
origin_name].list_channel_ids:
channel_obj = self.plugin_utils.origins.origins_dict[
origin_name].get_channel_obj(fhdhr_channel_id)
if channel_obj:
if channel_obj.enabled:
channelslist[channel_obj.number] = channel_obj
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
for channel in sorted_channel_list:
channel_obj = channelslist[channel]
lineup_dict = {
'GuideNumber': channel_obj.number,
'GuideName': channel_obj.dict['name'],
'Tags': ",".join(channel_obj.dict['tags']),
'URL': '/hdhr/%s/auto/v%s' % (origin_name, channel_obj.number),
'HD': channel_obj.dict["HD"],
"Favorite": channel_obj.dict["favorite"],
}
lineup_dict["URL"] = "%s%s" % (base_url, lineup_dict["URL"])
if show == "found" and channel_obj.enabled:
lineup_dict["Enabled"] = 1
elif show == "found" and not channel_obj.enabled:
lineup_dict["Enabled"] = 0
chan_guide.append(lineup_dict)
return chan_guide
def get(self, *args):
channels_dict = {
"Total Channels": len(self.fhdhr.device.channels.get_channels()),
"Enabled": 0
}
channelslist = {}
for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels()]:
channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
channel_dict = channel_obj.dict.copy()
channel_dict["number"] = channel_obj.number
channel_dict["chan_thumbnail"] = channel_obj.thumbnail
channel_dict["play_url"] = channel_obj.play_url
channelslist[channel_dict["number"]] = channel_dict
if channel_dict["enabled"]:
channels_dict["Enabled"] += 1
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channelslist[channel])
return render_template('channels.html', session=session, request=request, fhdhr=self.fhdhr, channelslist=sorted_chan_guide, channels_dict=channels_dict, list=list)
def sorted_channel_dicts(self):
channels_dict = self.dict_of_channel_dicts_by_number
# Sort the channels
sorted_channel_list = channel_sort(list(channels_dict.keys()))
sorted_chan_guide = []
for channel_number in sorted_channel_list:
sorted_chan_guide.append(channels_dict[channel_number])
return sorted_chan_guide
def get(self, *args):
origin_methods = self.fhdhr.origins.valid_origins
if len(self.fhdhr.origins.valid_origins):
origin = request.args.get(
'origin',
default=self.fhdhr.origins.valid_origins[0],
type=str)
if origin not in origin_methods:
origin = origin_methods[0]
channels_dict = {
"Total Channels":
len(self.fhdhr.device.channels.get_channels(origin)),
"Enabled":
0
}
channelslist = {}
for fhdhr_id in [
x["id"]
for x in self.fhdhr.device.channels.get_channels(origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", fhdhr_id, origin)
channel_dict = channel_obj.dict.copy()
channel_dict["number"] = channel_obj.number
channel_dict["chan_thumbnail"] = channel_obj.thumbnail
channel_dict["m3u_url"] = channel_obj.api_m3u_url
channelslist[channel_dict["number"]] = channel_dict
if channel_dict["enabled"]:
channels_dict["Enabled"] += 1
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channelslist[channel])
else:
origin = None
sorted_chan_guide = []
channels_dict = {"Total Channels": 0, "Enabled": 0}
return render_template('channels.html',
request=request,
session=session,
fhdhr=self.fhdhr,
channelslist=sorted_chan_guide,
channels_dict=channels_dict,
origin=origin,
origin_methods=origin_methods,
list=list)
def get(self, *args):
base_url = request.url_root[:-1]
show = request.args.get('show', default="all", type=str)
origin = self.source
channelslist = {}
sorted_chan_guide = []
for fhdhr_id in [
x["id"]
for x in self.fhdhr.device.channels.get_channels(origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", fhdhr_id, origin)
if channel_obj.enabled:
channelslist[channel_obj.number] = channel_obj
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
for channel in sorted_channel_list:
channel_obj = channelslist[channel]
lineup_dict = {
'GuideNumber': channel_obj.number,
'GuideName': channel_obj.dict['name'],
'Tags': ",".join(channel_obj.dict['tags']),
'URL': '/hdhr/auto/v%s' % channel_obj.number,
'HD': channel_obj.dict["HD"],
"Favorite": channel_obj.dict["favorite"],
}
lineup_dict["URL"] = "%s%s" % (base_url, lineup_dict["URL"])
if show == "found" and channel_obj.enabled:
lineup_dict["Enabled"] = 1
elif show == "found" and not channel_obj.enabled:
lineup_dict["Enabled"] = 0
sorted_chan_guide.append(lineup_dict)
out = xml.etree.ElementTree.Element('Lineup')
for lineup_dict in sorted_chan_guide:
program_out = sub_el(out, 'Program')
for key in list(lineup_dict.keys()):
sub_el(program_out, str(key), str(lineup_dict[key]))
fakefile = BytesIO()
fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
lineup_xml = fakefile.getvalue()
return Response(status=200,
response=lineup_xml,
mimetype='application/xml')
def get(self, devicekey, *args):
"""Returns the current channels."""
out = xml.etree.ElementTree.Element('MediaContainer')
if devicekey.startswith(self.fhdhr.config.dict["main"]["uuid"]):
origin_name = devicekey.split(
self.fhdhr.config.dict["main"]["uuid"])[-1]
out.set(
'size',
str(self.fhdhr.origins.origins_dict[origin_name].channels.
count_channels))
channelslist = {}
for fhdhr_channel_id in self.fhdhr.origins.origins_dict[
origin_name].channels.list_channel_ids:
channel_obj = self.fhdhr.origins.origins_dict[
origin_name].channels.get_channel_obj(
"id", fhdhr_channel_id)
if channel_obj:
if channel_obj.enabled:
channelslist[channel_obj.number] = channel_obj
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
for channel in sorted_channel_list:
channel_obj = channelslist[channel]
sub_el(
out,
'Channel',
drm="0",
channelIdentifier="id://%s" % channel_obj.number,
name=channel_obj.dict["name"],
origin_name=channel_obj.dict["callsign"],
number=str(channel_obj.number),
type="tv",
# TODO param
signalStrength="100",
signalQuality="100",
)
fakefile = BytesIO()
fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
device_xml = fakefile.getvalue()
return Response(status=200,
response=device_xml,
mimetype='application/xml')
def get(self, *args):
base_url = request.url_root[:-1]
show = request.args.get('show', default="all", type=str)
origin = self.source
channelslist = {}
sorted_chan_guide = []
for fhdhr_id in [
x["id"]
for x in self.fhdhr.device.channels.get_channels(origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", fhdhr_id, origin)
if channel_obj.enabled:
channelslist[channel_obj.number] = channel_obj
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
for channel in sorted_channel_list:
channel_obj = channelslist[channel]
lineup_dict = {
'GuideNumber': channel_obj.number,
'GuideName': channel_obj.dict['name'],
'Tags': ",".join(channel_obj.dict['tags']),
'URL': '/hdhr/auto/v%s' % channel_obj.number,
'HD': channel_obj.dict["HD"],
"Favorite": channel_obj.dict["favorite"],
}
lineup_dict["URL"] = "%s%s" % (base_url, lineup_dict["URL"])
if show == "found" and channel_obj.enabled:
lineup_dict["Enabled"] = 1
elif show == "found" and not channel_obj.enabled:
lineup_dict["Enabled"] = 0
sorted_chan_guide.append(lineup_dict)
lineup_json = json.dumps(sorted_chan_guide, indent=4)
return Response(status=200,
response=lineup_json,
mimetype='application/json')
def handler(self, *args):
origin_methods = self.fhdhr.origins.list_origins
if self.fhdhr.origins.count_origins:
origin_name = request.args.get('origin', default=self.fhdhr.origins.first_origin, type=str)
if origin_name not in origin_methods:
origin_name = origin_methods[0]
channels_dict = {
"Total Channels": self.fhdhr.origins.origins_dict[origin_name].channels.count_channels,
"Enabled": 0
}
channelslist = {}
for fhdhr_channel_id in self.fhdhr.origins.origins_dict[origin_name].channels.list_channel_ids:
channel_obj = self.fhdhr.origins.origins_dict[origin_name].channels.find_channel_obj(fhdhr_channel_id, searchkey="id")
if channel_obj:
channel_dict = channel_obj.dict.copy()
channel_dict["number"] = channel_obj.number
channel_dict["chan_thumbnail"] = channel_obj.thumbnail
channel_dict["m3u_url"] = channel_obj.api_m3u_url
channelslist[channel_dict["number"]] = channel_dict
if channel_dict["enabled"]:
channels_dict["Enabled"] += 1
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channelslist[channel])
else:
origin_name = None
sorted_chan_guide = []
channels_dict = {
"Total Channels": 0,
"Enabled": 0
}
return render_template('channels.html', request=request, session=session, fhdhr=self.fhdhr, channelslist=sorted_chan_guide, channels_dict=channels_dict, origin_name=origin_name, origin_methods=origin_methods, list=list)
def get(self, *args):
base_url = request.url_root[:-1]
show = request.args.get('show', default="all", type=str)
channelslist = {}
for fhdhr_id in [
x["id"] for x in self.fhdhr.device.channels.get_channels()
]:
channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
if channel_obj.enabled or show == "found":
lineup_dict = channel_obj.lineup_dict
lineup_dict["URL"] = "%s%s" % (base_url, lineup_dict["URL"])
if show == "found" and channel_obj.enabled:
lineup_dict["Enabled"] = 1
elif show == "found" and not channel_obj.enabled:
lineup_dict["Enabled"] = 0
channelslist[channel_obj.number] = lineup_dict
# Sort the channels
sorted_channel_list = channel_sort(list(channelslist.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channelslist[channel])
out = xml.etree.ElementTree.Element('Lineup')
for lineup_dict in sorted_chan_guide:
program_out = sub_el(out, 'Program')
for key in list(lineup_dict.keys()):
sub_el(program_out, str(key), str(lineup_dict[key]))
fakefile = BytesIO()
fakefile.write(b'<?xml version="1.0" encoding="UTF-8"?>\n')
fakefile.write(xml.etree.ElementTree.tostring(out, encoding='UTF-8'))
lineup_xml = fakefile.getvalue()
return Response(status=200,
response=lineup_xml,
mimetype='application/xml')
def get(self, *args):
nowtime = datetime.datetime.utcnow().timestamp()
chan_guide_list = []
source = request.args.get('source',
default=self.fhdhr.device.epg.def_method,
type=str)
epg_methods = self.fhdhr.device.epg.valid_epg_methods
if source not in epg_methods:
source = self.fhdhr.device.epg.def_method
whatson = self.fhdhr.device.epg.whats_on_allchans(source)
# Sort the channels
sorted_channel_list = channel_sort(list(whatson.keys()))
sorted_chan_guide = {}
for channel in sorted_channel_list:
sorted_chan_guide[channel] = whatson[channel]
for channel in list(sorted_chan_guide.keys()):
if sorted_chan_guide[channel]["listing"][0]["time_end"]:
remaining_time = humanized_time(
sorted_chan_guide[channel]["listing"][0]["time_end"] -
nowtime)
else:
remaining_time = "N/A"
chan_dict = {
"name":
sorted_chan_guide[channel]["name"],
"number":
sorted_chan_guide[channel]["number"],
"chan_thumbnail":
sorted_chan_guide[channel]["thumbnail"],
"listing_title":
sorted_chan_guide[channel]["listing"][0]["title"],
"listing_thumbnail":
sorted_chan_guide[channel]["listing"][0]["thumbnail"],
"listing_description":
sorted_chan_guide[channel]["listing"][0]["description"],
"listing_remaining_time":
str(remaining_time)
}
for time_item in ["time_start", "time_end"]:
if not sorted_chan_guide[channel]["listing"][0][time_item]:
chan_dict["listing_%s" % time_item] = "N/A"
elif str(sorted_chan_guide[channel]["listing"][0]
[time_item]).endswith(tuple(["+0000", "+00:00"])):
chan_dict["listing_%s" % time_item] = str(
sorted_chan_guide[channel]["listing"][0][time_item])
else:
chan_dict["listing_%s" % time_item] = str(
datetime.datetime.fromtimestamp(
sorted_chan_guide[channel]["listing"][0]
[time_item]))
if source in [
"blocks", "origin",
self.fhdhr.config.dict["main"]["dictpopname"]
]:
chan_obj = self.fhdhr.device.channels.get_channel_obj(
"origin_id", sorted_chan_guide[channel]["id"])
chan_dict["name"] = chan_obj.dict["name"]
chan_dict["number"] = chan_obj.number
chan_dict["chan_thumbnail"] = chan_obj.thumbnail
chan_dict["enabled"] = chan_obj.dict["enabled"]
chan_dict["play_url"] = chan_obj.play_url
chan_dict["listing_thumbnail"] = chan_dict[
"listing_thumbnail"] or chan_obj.thumbnail
else:
if not chan_dict["listing_thumbnail"]:
chan_dict["listing_thumbnail"] = chan_dict[
"chan_thumbnail"]
if not chan_dict["listing_thumbnail"]:
chan_dict[
"listing_thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % chan_dict[
"number"]
chan_guide_list.append(chan_dict)
return render_template('guide.html',
session=session,
request=request,
fhdhr=self.fhdhr,
chan_guide_list=chan_guide_list,
epg_methods=epg_methods,
source=source)
def get(self, *args):
nowtime = datetime.datetime.utcnow().timestamp()
source = request.args.get('source',
default=self.fhdhr.device.epg.def_method,
type=str)
epg_methods = self.fhdhr.device.epg.valid_epg_methods
if source not in epg_methods:
source = self.fhdhr.device.epg.def_method
origin_methods = self.fhdhr.origins.valid_origins
channelslist = {}
if not source:
return render_template('guide.html',
request=request,
session=session,
fhdhr=self.fhdhr,
channelslist=channelslist,
epg_methods=epg_methods,
origin=source,
origin_methods=origin_methods,
list=list)
whatson_all = self.fhdhr.device.epg.whats_on_allchans(source)
if source in origin_methods:
sorted_channel_list = channel_sort([
self.fhdhr.device.channels.list[source][x].number
for x in list(self.fhdhr.device.channels.list[source].keys())
])
for channel in sorted_channel_list:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"number", channel, source)
channel_dict = channel_obj.dict.copy()
now_playing = whatson_all[channel]
channel_dict["number"] = channel_obj.number
channel_dict["chan_thumbnail"] = channel_obj.thumbnail
channel_dict["m3u_url"] = channel_obj.api_m3u_url
current_listing = now_playing["listing"][0]
channel_dict["listing_title"] = current_listing["title"]
channel_dict["listing_thumbnail"] = current_listing[
"thumbnail"]
channel_dict["listing_description"] = current_listing[
"description"]
if current_listing["time_end"]:
channel_dict["listing_remaining_time"] = humanized_time(
current_listing["time_end"] - nowtime)
else:
channel_dict["listing_remaining_time"] = "N/A"
for time_item in ["time_start", "time_end"]:
if not current_listing[time_item]:
channel_dict["listing_%s" % time_item] = "N/A"
elif str(current_listing[time_item]).endswith(
tuple(["+0000", "+00:00"])):
channel_dict["listing_%s" % time_item] = str(
current_listing[time_item])
else:
channel_dict["listing_%s" % time_item] = str(
datetime.datetime.fromtimestamp(
current_listing[time_item]))
channelslist[channel_obj.number] = channel_dict
elif source in epg_methods:
sorted_channel_list = channel_sort(
[x for x in list(whatson_all.keys())])
for channel in sorted_channel_list:
channel_dict = {
"name": whatson_all[channel]["name"],
"number": whatson_all[channel]["number"],
"chan_thumbnail": whatson_all[channel]["thumbnail"],
}
now_playing = whatson_all[channel]
current_listing = now_playing["listing"][0]
channel_dict["listing_title"] = current_listing["title"]
channel_dict["listing_thumbnail"] = current_listing[
"thumbnail"]
channel_dict["listing_description"] = current_listing[
"description"]
if current_listing["time_end"]:
channel_dict["listing_remaining_time"] = humanized_time(
current_listing["time_end"] - nowtime)
else:
channel_dict["listing_remaining_time"] = "N/A"
for time_item in ["time_start", "time_end"]:
if not current_listing[time_item]:
channel_dict["listing_%s" % time_item] = "N/A"
elif str(current_listing[time_item]).endswith(
tuple(["+0000", "+00:00"])):
channel_dict["listing_%s" % time_item] = str(
current_listing[time_item])
else:
channel_dict["listing_%s" % time_item] = str(
datetime.datetime.fromtimestamp(
current_listing[time_item]))
channelslist[channel] = channel_dict
return render_template('guide.html',
request=request,
session=session,
fhdhr=self.fhdhr,
channelslist=channelslist,
epg_methods=epg_methods,
origin=source,
origin_methods=origin_methods,
list=list)
def create_xmltv(self, base_url, epgdict, source):
if not epgdict:
return self.xmltv_empty(source)
epgdict = epgdict.copy()
out = self.xmltv_headers(source)
sorted_epgdict = {}
sorted_channel_list = channel_sort([x for x in list(epgdict.keys())])
for epgchan in sorted_channel_list:
sorted_epgdict[epgchan] = epgdict[epgchan]
for c in list(epgdict.keys()):
c_out = sub_el(out, 'channel', id=str(epgdict[c]['id']))
sub_el(c_out, 'display-name', text=epgdict[c]['name'])
sub_el(c_out, 'display-name',
text='%s %s' % (epgdict[c]['number'], epgdict[c]['callsign']))
sub_el(c_out, 'display-name',
text='%s %s %s' % (epgdict[c]['number'], epgdict[c]['callsign'], str(epgdict[c]['id'])))
sub_el(c_out, 'display-name', text=epgdict[c]['number'])
sub_el(c_out, 'display-name', text=epgdict[c]['callsign'])
if self.fhdhr.config.dict["epg"]["images"] == "proxy":
sub_el(c_out, 'icon', src=("%s/api/images?method=get&type=channel&id=%s" % (base_url, epgdict[c]['id'])))
else:
sub_el(c_out, 'icon', src=(epgdict[c]["thumbnail"]))
for channelnum in list(epgdict.keys()):
channel_listing = epgdict[channelnum]['listing']
for program in channel_listing:
xmltvtimetamps = self.timestamp_to_datetime(program['time_start'], program['time_end'], source)
prog_out = sub_el(out, 'programme',
start=xmltvtimetamps['time_start'],
stop=xmltvtimetamps['time_end'],
channel=str(epgdict[channelnum]["id"]))
sub_el(prog_out, 'title', lang='en', text=program['title'])
sub_el(prog_out, 'desc', lang='en', text=program['description'])
if program['seasonnumber'] and program['episodenumber']:
sub_el(prog_out, 'sub-title', lang='en', text=program['sub-title'])
else:
sub_el(prog_out, 'sub-title', lang='en', text='Movie: %s' % program['sub-title'])
sub_el(prog_out, 'length', units='minutes', text=str(int(program['duration_minutes'])))
for f in program['genres']:
sub_el(prog_out, 'category', lang='en', text=f)
sub_el(prog_out, 'genre', lang='en', text=f)
if program['seasonnumber'] and program['episodenumber']:
s_ = int(str(program['seasonnumber']), 10)
e_ = int(str(program['episodenumber']), 10)
sub_el(prog_out, 'episode-num', system='dd_progid',
text=str(program['id']))
sub_el(prog_out, 'episode-num', system='common',
text='S%02dE%02d' % (s_, e_))
sub_el(prog_out, 'episode-num', system='xmltv_ns',
text='%d.%d.' % (int(s_)-1, int(e_)-1))
sub_el(prog_out, 'episode-num', system='SxxExx">S',
text='S%02dE%02d' % (s_, e_))
if program["thumbnail"]:
if self.fhdhr.config.dict["epg"]["images"] == "proxy":
sub_el(prog_out, 'icon', src=("%s/api/images?method=get&type=content&id=%s" % (base_url, program['id'])))
else:
sub_el(prog_out, 'icon', src=(program["thumbnail"]))
else:
sub_el(prog_out, 'icon', src=("%s/api/images?method=generate&type=content&message=%s" % (base_url, urllib.parse.quote(program['title']))))
if program['rating']:
rating_out = sub_el(prog_out, 'rating', system="MPAA")
sub_el(rating_out, 'value', text=program['rating'])
if program['isnew']:
sub_el(prog_out, 'new')
return self.xmltv_file(out)
def handler(self, *args):
method = request.args.get('method', default=None, type=str)
redirect_url = request.args.get('redirect', default=None, type=str)
origin_methods = self.fhdhr.origins.list_origins
origin_name = request.args.get('origin', default=None, type=str)
if origin_name and origin_name not in origin_methods:
return "%s Invalid channels origin" % origin_name
if method == "get":
channels_info = {}
if not origin_name:
origin_list = origin_methods
else:
origin_list = [origin_name]
for origin_name in origin_list:
channels_info[origin_name] = {}
for fhdhr_channel_id in self.fhdhr.origins.origins_dict[
origin_name].channels.list_channel_ids:
channel_obj = self.fhdhr.origins.origins_dict[
origin_name].channels.channel_list[fhdhr_channel_id]
if channel_obj:
channel_dict = channel_obj.dict.copy()
channel_dict["m3u_url"] = channel_obj.api_m3u_url
channel_dict["stream_url"] = channel_obj.api_stream_url
channels_info[origin_name][
channel_obj.number] = channel_dict
# Sort the channels
sorted_channel_list = channel_sort(
list(channels_info[origin_name].keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(
channels_info[origin_name][channel])
channels_info[origin_name] = sorted_chan_guide
channels_info_json = json.dumps(channels_info, indent=4)
return Response(status=200,
response=channels_info_json,
mimetype='application/json')
elif method == "favorite":
channel = request.args.get('channel', default=None, type=str)
if not channel:
if redirect_url:
if "?" in redirect_url:
return redirect(
"%s&retmessage=%s" %
(redirect_url,
urllib.parse.quote("%s Failed" % method)))
else:
return redirect(
"%s?retmessage=%s" %
(redirect_url,
urllib.parse.quote("%s Failed" % method)))
else:
return "%s Falied" % method
if channel.startstwith(tuple(["+", "-", "x"])):
channel_method = channel[0]
channel_number = channel[1:]
if str(channel_number) not in [
str(x)
for x in self.fhdhr.origins.origins_dict[origin_name].
channels.create_channel_list("number")
]:
response = Response("Not Found", status=404)
response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
abort(response)
if channel_method == "+":
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_enablement(
channel_number, channel_method, "number")
elif channel_method == "-":
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_enablement(
channel_number, channel_method, "number")
elif channel_method == "x":
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_enablement(
channel_number, "toggle", "number")
else:
self.fhdhr.logger.warning("Unknown favorite command %s" %
request.args['favorite'])
return abort(200, "Not a valid favorite command")
elif method in ["enable", "disable"]:
channel = request.args.get('channel', default=None, type=str)
if channel == "all":
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_enablement_all(method)
elif not channel or str(channel) not in [
str(x)
for x in self.fhdhr.origins.origins_dict[origin_name].
channels.create_channel_list("number")
]:
if redirect_url:
if "?" in redirect_url:
return redirect(
"%s&retmessage=%s" %
(redirect_url,
urllib.parse.quote("%s Failed" % method)))
else:
return redirect(
"%s?retmessage=%s" %
(redirect_url,
urllib.parse.quote("%s Failed" % method)))
else:
return "%s Falied" % method
else:
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_enablement(
channel, method, "id")
elif method == "update":
channel_id = request.form.get('id', None)
updatedict = {}
for key in list(request.form.keys()):
if key != "id":
if key in ["name", "callsign", "thumbnail"]:
updatedict[key] = str(request.form.get(key))
elif key in ["number"]:
number = str(request.form.get(key))
if "." in number:
updatedict["subnumber"] = number.split(".")[1]
updatedict["number"] = number.split(".")[0]
else:
updatedict["number"] = number
elif key in ["enabled"]:
confvalue = request.form.get(key)
if str(confvalue).lower() in ["false"]:
confvalue = False
elif str(confvalue).lower() in ["true"]:
confvalue = True
updatedict[key] = confvalue
elif key in ["favorite", "HD"]:
updatedict[key] = int(request.form.get(key))
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_status(
channel_id, updatedict, "id")
elif method == "modify":
channels_list = json.loads(request.form.get('channels', []))
for channel in channels_list:
updatedict = {}
for key in list(channel.keys()):
if key != "id":
if key in ["name", "callsign", "thumbnail"]:
updatedict[key] = str(channel[key])
elif key in ["number"]:
number = str(channel[key])
updatedict["number"] = number
elif key in ["enabled"]:
confvalue = channel[key]
if str(confvalue).lower() in ["false"]:
confvalue = False
elif str(confvalue).lower() in ["true"]:
confvalue = True
updatedict[key] = confvalue
elif key in ["favorite", "HD"]:
updatedict[key] = int(channel[key])
else:
channel_id = str(channel[key])
self.fhdhr.origins.origins_dict[
origin_name].channels.set_channel_status(
channel_id, updatedict, "id")
elif method == "scan":
self.fhdhr.origins.origins_dict[
origin_name].channels.run_schedule_scan()
elif method == "delete":
fhdhr_channel_id = request.args.get('fhdhr_channel_id',
default=None,
type=str)
if fhdhr_channel_id:
self.fhdhr.origins.origins_dict[
origin_name].channels.delete_channel(fhdhr_channel_id)
self.fhdhr.device.epg.delete_channel(fhdhr_channel_id,
origin_name)
else:
return "Invalid Method"
if redirect_url:
if "?" in redirect_url:
return redirect(
"%s&retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return redirect(
"%s?retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
if method == "scan":
return redirect('/lineup_status.json')
else:
return "%s Success" % method
def get(self, *args):
method = request.args.get('method', default=None, type=str)
redirect_url = request.args.get('redirect', default=None, type=str)
if method == "get":
channels_info = {}
for fhdhr_id in [x["id"] for x in self.fhdhr.device.channels.get_channels()]:
channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
channel_dict = channel_obj.dict.copy()
channel_dict["play_url"] = channel_obj.play_url
channel_dict["stream_url"] = channel_obj.stream_url
channels_info[channel_obj.number] = channel_dict
# Sort the channels
sorted_channel_list = channel_sort(list(channels_info.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channels_info[channel])
channels_info_json = json.dumps(sorted_chan_guide, indent=4)
return Response(status=200,
response=channels_info_json,
mimetype='application/json')
elif method == "favorite":
channel = request.args.get('channel', default=None, type=str)
if not channel:
if redirect_url:
return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Failed" % method))
else:
return "%s Falied" % method
if channel.startstwith(tuple(["+", "-", "x"])):
channel_method = channel[0]
channel_number = channel[1:]
if str(channel_number) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
response = Response("Not Found", status=404)
response.headers["X-fHDHR-Error"] = "801 - Unknown Channel"
self.fhdhr.logger.error(response.headers["X-fHDHR-Error"])
abort(response)
if channel_method == "+":
self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method)
elif channel_method == "-":
self.fhdhr.device.channels.set_channel_enablement("number", channel_number, channel_method)
elif channel_method == "x":
self.fhdhr.device.channels.set_channel_enablement("number", channel_number, "toggle")
else:
self.fhdhr.logger.warning("Unknown favorite command " + request.args['favorite'])
return abort(200, "Not a valid favorite command")
elif method in ["enable", "disable"]:
channel = request.args.get('channel', default=None, type=str)
if channel == "all":
self.fhdhr.device.channels.set_channel_enablement_all(method)
elif not channel or str(channel) not in [str(x) for x in self.fhdhr.device.channels.get_channel_list("number")]:
if redirect_url:
return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Failed" % method))
else:
return "%s Falied" % method
else:
self.fhdhr.device.channels.set_channel_enablement("number", channel, method)
elif method == "update":
channel_id = request.form.get('id', None)
updatedict = {}
for key in list(request.form.keys()):
if key != "id":
if key in ["name", "callsign", "thumbnail"]:
updatedict[key] = str(request.form.get(key))
elif key in ["number"]:
number = str(request.form.get(key))
if "." in number:
updatedict["subnumber"] = number.split(".")[1]
updatedict["number"] = number.split(".")[0]
else:
updatedict["number"] = number
elif key in ["enabled"]:
confvalue = request.form.get(key)
if str(confvalue).lower() in ["false"]:
confvalue = False
elif str(confvalue).lower() in ["true"]:
confvalue = True
updatedict[key] = confvalue
elif key in ["favorite", "HD"]:
updatedict[key] = int(request.form.get(key))
self.fhdhr.device.channels.set_channel_status("id", channel_id, updatedict)
elif method == "modify":
channels_list = eval(request.form.get('channels', []))
for channel in channels_list:
updatedict = {}
for key in list(channel.keys()):
if key != "id":
if key in ["name", "callsign", "thumbnail"]:
updatedict[key] = str(channel[key])
elif key in ["number"]:
number = str(channel[key])
if "." in number:
updatedict["subnumber"] = number.split(".")[1]
updatedict["number"] = number.split(".")[0]
else:
updatedict["number"] = number
elif key in ["enabled"]:
confvalue = channel[key]
if str(confvalue).lower() in ["false"]:
confvalue = False
elif str(confvalue).lower() in ["true"]:
confvalue = True
updatedict[key] = confvalue
elif key in ["favorite", "HD"]:
updatedict[key] = int(channel[key])
else:
channel_id = str(channel[key])
self.fhdhr.device.channels.set_channel_status("id", channel_id, updatedict)
elif method == "scan":
self.fhdhr.device.channels.get_channels(forceupdate=True)
else:
return "Invalid Method"
if redirect_url:
return redirect(redirect_url + "?retmessage=" + urllib.parse.quote("%s Success" % method))
else:
if method == "scan":
return redirect('/lineup_status.json')
else:
return "%s Success" % method
def handler(self, *args):
base_url = request.url_root[:-1]
method = request.args.get('method', default="get", type=str)
channel = request.args.get('channel', default="all", type=str)
redirect_url = request.args.get('redirect', default=None, type=str)
if method == "get":
origin_methods = self.fhdhr.origins.list_origins
origin_name = request.args.get('origin', default=None, type=str)
if origin_name and origin_name not in origin_methods:
return "%s Invalid channels origin" % origin_name
FORMAT_DESCRIPTOR = "#EXTM3U"
RECORD_MARKER = "#EXTINF"
fakefile = StringIO()
xmltvurl = ('%s/api/xmltv?source=%s' % (base_url, origin_name))
fakefile.write("%s url-tvg=\"%s\" x-tvg-url=\"%s\"\n" %
(FORMAT_DESCRIPTOR, xmltvurl, xmltvurl))
channel_items = []
if origin_name:
if channel == "all":
fileName = "channels.m3u"
for fhdhr_channel_id in self.fhdhr.origins.origins_dict[
origin_name].channels.list_channel_ids:
channel_obj = self.fhdhr.origins.origins_dict[
origin_name].channels.find_channel_obj(
fhdhr_channel_id, searchkey="id")
if channel_obj:
if channel_obj.enabled:
channel_items.append(channel_obj)
elif str(channel) in [
str(x)
for x in self.fhdhr.origins.origins_dict[origin_name].
channels.create_channel_list("number")
]:
channel_obj = self.fhdhr.origins.origins_dict[
origin_name].channels.find_channel_obj(
channel, searchkey="number")
if channel_obj:
fileName = "%s.m3u" % channel_obj.number
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
elif channel != "all" and str(channel) in [
str(x)
for x in self.fhdhr.origins.origins_dict[origin_name].
channels.create_channel_list("id")
]:
channel_obj = self.fhdhr.origins.origins_dict[
origin_name].channels.find_channel_obj(channel,
searchkey="id")
if channel_obj:
fileName = "%s.m3u" % channel_obj.number
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
elif not origin_name and channel == "all":
fileName = "channels.m3u"
for origin_name in self.fhdhr.origins.list_origins:
for fhdhr_channel_id in self.fhdhr.origins.origins_dict[
origin_name].channels.list_channel_ids:
channel_obj = self.fhdhr.origins.origins_dict[
origin_name].channels.find_channel_obj(
fhdhr_channel_id, searchkey="id")
if channel_obj:
if channel_obj.enabled:
channel_items.append(channel_obj)
elif not origin_name and channel != "all" and str(channel) in [
str(x) for x in self.fhdhr.origins.get_channel_list("id")
]:
channel_obj = self.fhdhr.origins.channels.find_channel_obj(
channel, searchkey="id", origin_name=None)
if channel_obj:
fileName = "%s.m3u" % channel_obj.number
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
else:
return "Invalid Channel"
if not len(channel_items):
return "Invalid Channel"
stream_method = request.args.get('stream_method',
default=None,
type=str)
if stream_method and stream_method not in self.fhdhr.streammanager.streaming_methods:
return "Invalid stream_method"
channels_info = {}
for channel_obj in channel_items:
if self.fhdhr.config.dict["epg"][
"images"] == "proxy" or not channel_obj.thumbnail:
logourl = ('%s/api/images?method=get&type=channel&id=%s' %
(base_url, str(channel_obj.dict['origin_id'])))
else:
logourl = channel_obj.thumbnail
channels_info[channel_obj.number] = {
"channelID": str(channel_obj.dict['origin_id']),
"tvg-chno": str(channel_obj.number),
"tvg-name": str(channel_obj.dict['name']),
"tvg-id": str(channel_obj.number),
"tvg-logo": logourl,
"group-title": channel_obj.origin_name,
"group-titleb": str(channel_obj.dict['name']),
"stream_url":
"%s%s" % (base_url, channel_obj.api_stream_url)
}
if stream_method:
channels_info[channel_obj.number][
"stream_url"] += "&stream_method=%s" % stream_method
# Sort the channels
sorted_channel_list = channel_sort(list(channels_info.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channels_info[channel])
for channel_item_dict in sorted_chan_guide:
m3ustring = "%s:0 " % (RECORD_MARKER)
for chan_key in list(channel_item_dict.keys()):
if not chan_key.startswith(
tuple(["group-title", "stream_url"])):
m3ustring += "%s=\"%s\" " % (
chan_key, channel_item_dict[chan_key])
m3ustring += "group-title=\"%s\",%s\n" % (
channel_item_dict["group-title"],
channel_item_dict["group-titleb"])
m3ustring += "%s\n" % channel_item_dict["stream_url"]
fakefile.write(m3ustring)
channels_m3u = fakefile.getvalue()
resp = Response(status=200,
response=channels_m3u,
mimetype='audio/x-mpegurl')
resp.headers[
"content-disposition"] = "attachment; filename=%s" % fileName
return resp
if redirect_url:
if "?" in redirect_url:
return redirect(
"%s&retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return redirect(
"%s?retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return "%s Success" % method
def get(self, *args):
method = request.args.get('method', default="get", type=str)
source = request.args.get(
'source',
default=self.fhdhr.config.dict["epg"]["def_method"],
type=str)
if source not in list(
self.fhdhr.config.dict["epg"]["valid_methods"].keys()):
return "%s Invalid epg method" % source
redirect_url = request.args.get('redirect', default=None, type=str)
if method == "get":
epgdict = self.fhdhr.device.epg.get_epg(source)
if source in self.fhdhr.origins.valid_origins:
epgdict = epgdict.copy()
for c in list(epgdict.keys()):
chan_obj = self.fhdhr.device.channels.get_channel_obj(
"origin_id", epgdict[c]["id"], source)
epgdict[chan_obj.number] = epgdict.pop(c)
epgdict[chan_obj.number]["name"] = chan_obj.dict["name"]
epgdict[chan_obj.
number]["callsign"] = chan_obj.dict["callsign"]
epgdict[chan_obj.number]["number"] = chan_obj.number
epgdict[chan_obj.number]["id"] = chan_obj.dict["origin_id"]
epgdict[chan_obj.number]["thumbnail"] = chan_obj.thumbnail
# Sort the channels
sorted_channel_list = channel_sort(list(epgdict.keys()))
sorted_chan_guide = {}
for channel in sorted_channel_list:
sorted_chan_guide[channel] = epgdict[channel]
epg_json = json.dumps(sorted_chan_guide, indent=4)
return Response(status=200,
response=epg_json,
mimetype='application/json')
elif method == "current":
nowtime = datetime.datetime.utcnow().timestamp()
chan_guide_list = []
whatson = self.fhdhr.device.epg.whats_on_allchans(source)
# Sort the channels
sorted_channel_list = channel_sort(list(whatson.keys()))
sorted_chan_guide = {}
for channel in sorted_channel_list:
sorted_chan_guide[channel] = whatson[channel]
for channel in list(sorted_chan_guide.keys()):
if sorted_chan_guide[channel]["listing"][0]["time_end"]:
remaining_time = humanized_time(
sorted_chan_guide[channel]["listing"][0]["time_end"] -
nowtime)
else:
remaining_time = "N/A"
chan_dict = {
"name":
sorted_chan_guide[channel]["name"],
"number":
sorted_chan_guide[channel]["number"],
"chan_thumbnail":
sorted_chan_guide[channel]["thumbnail"],
"listing_title":
sorted_chan_guide[channel]["listing"][0]["title"],
"listing_thumbnail":
sorted_chan_guide[channel]["listing"][0]["thumbnail"],
"listing_description":
sorted_chan_guide[channel]["listing"][0]["description"],
"listing_remaining_time":
str(remaining_time)
}
for time_item in ["time_start", "time_end"]:
if not sorted_chan_guide[channel]["listing"][0][time_item]:
chan_dict["listing_%s" % time_item] = "N/A"
elif str(sorted_chan_guide[channel]["listing"][0]
[time_item]).endswith(tuple(["+0000", "+00:00"])):
chan_dict["listing_%s" %
time_item] = str(sorted_chan_guide[channel]
["listing"][0][time_item])
else:
chan_dict["listing_%s" % time_item] = str(
datetime.datetime.fromtimestamp(
sorted_chan_guide[channel]["listing"][0]
[time_item]))
if source in self.fhdhr.origins.valid_origins:
chan_obj = self.fhdhr.device.channels.get_channel_obj(
"origin_id", sorted_chan_guide[channel]["id"], source)
chan_dict["name"] = chan_obj.dict["name"]
chan_dict["number"] = chan_obj.number
chan_dict["chan_thumbnail"] = chan_obj.thumbnail
chan_dict["enabled"] = chan_obj.dict["enabled"]
chan_dict["m3u_url"] = chan_obj.api_m3u_url
chan_dict["listing_thumbnail"] = chan_dict[
"listing_thumbnail"] or chan_obj.thumbnail
else:
if not chan_dict["listing_thumbnail"]:
chan_dict["listing_thumbnail"] = chan_dict[
"chan_thumbnail"]
if not chan_dict["listing_thumbnail"]:
chan_dict[
"listing_thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % chan_dict[
"number"]
chan_guide_list.append(chan_dict)
epg_json = json.dumps(chan_guide_list, indent=4)
return Response(status=200,
response=epg_json,
mimetype='application/json')
elif method == "update":
self.fhdhr.device.epg.update(source)
elif method == "clearcache":
self.fhdhr.device.epg.clear_epg_cache(source)
else:
return "%s Invalid Method" % method
if redirect_url:
return redirect(
"%s?retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return "%s Success" % method
def handler(self, *args):
method = request.args.get('method', default="get", type=str)
source = request.args.get('source',
default=self.fhdhr.device.epg.def_method,
type=str)
if source not in self.fhdhr.device.epg.valid_epg_methods:
return "%s Invalid epg method" % source
redirect_url = request.args.get('redirect', default=None, type=str)
if method == "get":
epgdict = self.fhdhr.device.epg.get_epg(source)
# Sort the channels
sorted_channel_list = channel_sort(list(epgdict.keys()))
sorted_chan_guide = {}
for channel in sorted_channel_list:
sorted_chan_guide[channel] = epgdict[channel]
epg_json = json.dumps(sorted_chan_guide, indent=4)
return Response(status=200,
response=epg_json,
mimetype='application/json')
elif method == "current":
nowtime = datetime.datetime.utcnow().timestamp()
chan_guide_list = []
whatson = self.fhdhr.device.epg.whats_on_allchans(source)
# Sort the channels
sorted_channel_list = channel_sort(list(whatson.keys()))
sorted_chan_guide = {}
for channel in sorted_channel_list:
sorted_chan_guide[channel] = whatson[channel]
for channel in list(sorted_chan_guide.keys()):
if sorted_chan_guide[channel]["listing"][0]["time_end"]:
remaining_time = self.fhdhr.time.humanized_time(
sorted_chan_guide[channel]["listing"][0]["time_end"] -
nowtime)
else:
remaining_time = "N/A"
chan_dict = {
"name":
sorted_chan_guide[channel]["name"],
"number":
sorted_chan_guide[channel]["number"],
"chan_thumbnail":
sorted_chan_guide[channel]["thumbnail"],
"listing_title":
sorted_chan_guide[channel]["listing"][0]["title"],
"listing_thumbnail":
sorted_chan_guide[channel]["listing"][0]["thumbnail"],
"listing_description":
sorted_chan_guide[channel]["listing"][0]["description"],
"listing_remaining_time":
str(remaining_time)
}
for time_item in ["time_start", "time_end"]:
if not sorted_chan_guide[channel]["listing"][0][time_item]:
chan_dict["listing_%s" % time_item] = "N/A"
elif str(sorted_chan_guide[channel]["listing"][0]
[time_item]).endswith(tuple(["+0000", "+00:00"])):
chan_dict["listing_%s" %
time_item] = str(sorted_chan_guide[channel]
["listing"][0][time_item])
else:
chan_dict["listing_%s" % time_item] = str(
datetime.datetime.fromtimestamp(
sorted_chan_guide[channel]["listing"][0]
[time_item]))
if not chan_dict["listing_thumbnail"]:
chan_dict["listing_thumbnail"] = chan_dict[
"chan_thumbnail"]
if not chan_dict["listing_thumbnail"]:
chan_dict[
"listing_thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % chan_dict[
"number"]
chan_guide_list.append(chan_dict)
epg_json = json.dumps(chan_guide_list, indent=4)
return Response(status=200,
response=epg_json,
mimetype='application/json')
elif method == "update":
tags_list = self.fhdhr.scheduler.list_tags
if ("%s EPG Update" % source) not in tags_list:
self.fhdhr.device.epg.update(source)
else:
self.fhdhr.scheduler.run_from_tag("%s EPG Update" % source)
elif method == "map":
channels_list = json.loads(request.form.get('channels', []))
for channel in channels_list:
if channel["fhdhr_channel_id"] in [None, "None"]:
self.fhdhr.device.epg.unset_epg_chan_match(
channel["epg_method"], channel["id"])
else:
chan_obj = self.fhdhr.origins.origins_dict[
source].find_channel_obj(channel["fhdhr_channel_id"],
searchkey="id")
if chan_obj:
self.fhdhr.device.epg.set_epg_chan_match(
channel["epg_method"], channel["id"],
channel["fhdhr_channel_id"], chan_obj.origin_name)
elif method == "clearcache":
self.fhdhr.device.epg.clear_epg_cache(source)
else:
return "%s Invalid Method" % method
if redirect_url:
if "?" in redirect_url:
return redirect(
"%s&retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return redirect(
"%s?retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return "%s Success" % method
def get(self, *args):
base_url = request.url_root[:-1]
method = request.args.get('method', default="get", type=str)
channel = request.args.get('channel', default="all", type=str)
redirect_url = request.args.get('redirect', default=None, type=str)
if method == "get":
FORMAT_DESCRIPTOR = "#EXTM3U"
RECORD_MARKER = "#EXTINF"
fakefile = StringIO()
xmltvurl = ('%s/api/xmltv' % base_url)
fakefile.write("%s\n" %
(FORMAT_DESCRIPTOR + " " + "url-tvg=\"" + xmltvurl +
"\"" + " " + "x-tvg-url=\"" + xmltvurl + "\""))
channel_items = []
if channel == "all":
fileName = "channels.m3u"
for fhdhr_id in [
x["id"]
for x in self.fhdhr.device.channels.get_channels()
]:
channel_obj = self.fhdhr.device.channels.list[fhdhr_id]
if channel_obj.enabled:
channel_items.append(channel_obj)
elif str(channel) in [
str(x) for x in
self.fhdhr.device.channels.get_channel_list("number")
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"number", channel)
fileName = str(channel_obj.number) + ".m3u"
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
else:
return "Invalid Channel"
channels_info = {}
for channel_obj in channel_items:
if self.fhdhr.config.dict["epg"][
"images"] == "proxy" or not channel_obj.thumbnail:
logourl = ('%s/api/images?method=get&type=channel&id=%s' %
(base_url, str(channel_obj.dict['origin_id'])))
else:
logourl = channel_obj.thumbnail
channels_info[channel_obj.number] = {
"channelID": str(channel_obj.dict['origin_id']),
"tvg-chno": str(channel_obj.number),
"tvg-name": str(channel_obj.dict['name']),
"tvg-id": str(channel_obj.number),
"tvg-logo": logourl,
"group-title":
self.fhdhr.config.dict["fhdhr"]["friendlyname"],
"group-titleb": str(channel_obj.dict['name']),
"stream_url": "%s%s" % (base_url, channel_obj.stream_url)
}
# Sort the channels
sorted_channel_list = channel_sort(list(channels_info.keys()))
sorted_chan_guide = []
for channel in sorted_channel_list:
sorted_chan_guide.append(channels_info[channel])
for channel_item_dict in sorted_chan_guide:
m3ustring = "%s:0 " % (RECORD_MARKER)
for chan_key in list(channel_item_dict.keys()):
if not chan_key.startswith(
tuple(["group-title", "stream_url"])):
m3ustring += "%s=\"%s\" " % (
chan_key, channel_item_dict[chan_key])
m3ustring += "group-title=\"%s\"%s\n" % (
channel_item_dict["group-title"],
channel_item_dict["group-titleb"])
m3ustring += "%s\n" % channel_item_dict["stream_url"]
fakefile.write(m3ustring)
channels_m3u = fakefile.getvalue()
resp = Response(status=200,
response=channels_m3u,
mimetype='audio/x-mpegurl')
resp.headers[
"content-disposition"] = "attachment; filename=" + fileName
return resp
if redirect_url:
return redirect(redirect_url + "?retmessage=" +
urllib.parse.quote("%s Success" % method))
else:
return "%s Success" % method
def sorted_channel_number_list(self):
return channel_sort(self.list_channel_numbers)
def update(self, method=None):
if not method:
if not self.def_method:
return
method = self.def_method
if method not in self.valid_epg_methods:
if not self.def_method:
return
method = self.def_method
self.fhdhr.logger.info("Updating %s EPG cache." % method)
programguide = self.epg_handling[method].update_epg()
# sort the channel listings by time stamp
for cnum in list(programguide.keys()):
programguide[cnum]["listing"] = sorted(
programguide[cnum]["listing"], key=lambda i: i['time_start'])
# Gernate Block periods for between EPG data, if missing
clean_prog_guide = {}
desired_start_time = (datetime.datetime.today() + datetime.timedelta(
days=-abs(self.fhdhr.config.dict["epg"]["reverse_days"]))
).timestamp()
desired_end_time = (datetime.datetime.today() + datetime.timedelta(
days=self.fhdhr.config.dict["epg"]["forward_days"])).timestamp()
for cnum in list(programguide.keys()):
if cnum not in list(clean_prog_guide.keys()):
clean_prog_guide[cnum] = programguide[cnum].copy()
clean_prog_guide[cnum]["listing"] = []
if method in [
origin for origin in list(self.origins.origins_dict.keys())
]:
chan_obj = self.channels.get_channel_obj(
"origin_id", programguide[cnum]["id"])
else:
chan_obj = None
# Generate Blocks for Channels containing No Lisiings
if not len(programguide[cnum]["listing"]):
timestamps = self.blocks.timestamps_between(
desired_start_time, desired_end_time)
clean_prog_dicts = self.blocks.empty_channel_epg(
timestamps,
chan_dict=programguide[cnum],
chan_obj=chan_obj)
clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
else:
# Clean Timetamps from old xmltv method to timestamps
progindex = 0
for program_item in programguide[cnum]["listing"]:
for time_item in ["time_start", "time_end"]:
time_value = programguide[cnum]["listing"][progindex][
time_item]
if str(time_value).endswith("+00:00"):
programguide[cnum]["listing"][progindex][
time_item] = datetime.datetime.strptime(
time_value,
'%Y%m%d%H%M%S +00:00').timestamp()
elif str(time_value).endswith("+0000"):
programguide[cnum]["listing"][progindex][
time_item] = datetime.datetime.strptime(
time_value,
'%Y%m%d%H%M%S +0000').timestamp()
else:
programguide[cnum]["listing"][progindex][
time_item] = int(time_value)
progindex += 1
# Generate time before the listing actually starts
first_prog_time = programguide[cnum]["listing"][0][
'time_start']
if desired_start_time < first_prog_time:
timestamps = self.blocks.timestamps_between(
desired_start_time, first_prog_time)
clean_prog_dicts = self.blocks.empty_channel_epg(
timestamps,
chan_dict=programguide[cnum],
chan_obj=chan_obj)
clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
# Generate time blocks between events if chunks of time are missing
progindex = 0
for program_item in programguide[cnum]["listing"]:
try:
nextprog_dict = programguide[cnum]["listing"][progindex
+ 1]
except IndexError:
nextprog_dict = None
if not nextprog_dict:
clean_prog_guide[cnum]["listing"].append(program_item)
else:
if nextprog_dict['time_start'] > program_item[
'time_end']:
timestamps = self.blocks.timestamps_between(
program_item['time_end'],
nextprog_dict['time_start'])
clean_prog_dicts = self.blocks.empty_channel_epg(
timestamps,
chan_dict=programguide[cnum],
chan_obj=chan_obj)
clean_prog_guide[cnum]["listing"].extend(
clean_prog_dicts)
else:
clean_prog_guide[cnum]["listing"].append(
program_item)
progindex += 1
# Generate time after the listing actually ends
end_prog_time = programguide[cnum]["listing"][progindex][
'time_end']
if desired_end_time > end_prog_time:
timestamps = self.blocks.timestamps_between(
end_prog_time, desired_end_time)
clean_prog_dicts = self.blocks.empty_channel_epg(
timestamps,
chan_dict=programguide[cnum],
chan_obj=chan_obj)
clean_prog_guide[cnum]["listing"].extend(clean_prog_dicts)
programguide = clean_prog_guide.copy()
# if a stock method, generate Blocks EPG for missing channels
if method in [
origin for origin in list(self.origins.origins_dict.keys())
]:
timestamps = self.blocks.timestamps
for fhdhr_id in [
x["id"] for x in self.channels.get_channels(method)
]:
chan_obj = self.channels.get_channel_obj(
"id", fhdhr_id, method)
if str(chan_obj.number) not in list(programguide.keys()):
programguide[str(chan_obj.number)] = chan_obj.epgdict
clean_prog_dicts = self.blocks.empty_channel_epg(
timestamps, chan_obj=chan_obj)
programguide[str(
chan_obj.number)]["listing"].extend(clean_prog_dicts)
# Make Thumbnails for missing thumbnails
for cnum in list(programguide.keys()):
if not programguide[cnum]["thumbnail"]:
programguide[cnum][
"thumbnail"] = "/api/images?method=generate&type=channel&message=%s" % programguide[
cnum]["number"]
programguide[cnum]["listing"] = sorted(
programguide[cnum]["listing"], key=lambda i: i['time_start'])
prog_index = 0
for program_item in programguide[cnum]["listing"]:
if not programguide[cnum]["listing"][prog_index]["thumbnail"]:
programguide[cnum]["listing"][prog_index][
"thumbnail"] = programguide[cnum]["thumbnail"]
prog_index += 1
# Get Totals
total_channels = len(list(programguide.keys()))
total_programs = 0
# Sort the channels
sorted_channel_list = channel_sort(list(programguide.keys()))
sorted_chan_guide = {}
for channel in sorted_channel_list:
total_programs += len(programguide[cnum]["listing"])
sorted_chan_guide[channel] = programguide[channel]
self.epgdict[method] = sorted_chan_guide
self.fhdhr.db.set_fhdhr_value("epg_dict", method, programguide)
self.fhdhr.db.set_fhdhr_value("update_time", method, time.time())
self.fhdhr.logger.info(
"Wrote %s EPG cache. %s Programs for %s Channels" %
(method, total_programs, total_channels))
def get(self, *args):
base_url = request.url_root[:-1]
method = request.args.get('method', default="get", type=str)
channel = request.args.get('channel', default="all", type=str)
redirect_url = request.args.get('redirect', default=None, type=str)
if method == "get":
origin_methods = self.fhdhr.origins.valid_origins
origin = request.args.get('origin', default=None, type=str)
if origin and origin not in origin_methods:
return "%s Invalid channels origin" % origin
channel_info_w3u = {
"name": self.fhdhr.config.dict["fhdhr"]["friendlyname"],
"image": '%s/favicon.ico' % base_url,
"epg": '%s/api/xmltv' % base_url,
"stations": []
}
channel_items = []
if origin:
if channel == "all":
fileName = "channels.w3u"
for fhdhr_id in [
x["id"] for x in
self.fhdhr.device.channels.get_channels(origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", fhdhr_id, origin)
if channel_obj.enabled:
channel_items.append(channel_obj)
elif str(channel) in [
str(x)
for x in self.fhdhr.device.channels.get_channel_list(
"number", origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"number", channel, origin)
fileName = "%s.w3u" % channel_obj.number
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
elif channel != "all" and str(channel) in [
str(x)
for x in self.fhdhr.device.channels.get_channel_list(
"id", origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", channel, origin)
fileName = "%s.w3u" % channel_obj.number
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
elif not origin and channel == "all":
fileName = "channels.w3u"
for origin in list(self.fhdhr.origins.origins_dict.keys()):
for fhdhr_id in [
x["id"] for x in
self.fhdhr.device.channels.get_channels(origin)
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", fhdhr_id, origin)
if channel_obj.enabled:
channel_items.append(channel_obj)
elif not origin and channel != "all" and str(channel) in [
str(x)
for x in self.fhdhr.device.channels.get_channel_list("id")
]:
channel_obj = self.fhdhr.device.channels.get_channel_obj(
"id", channel)
fileName = "%s.w3u" % channel_obj.number
if channel_obj.enabled:
channel_items.append(channel_obj)
else:
return "Channel Disabled"
else:
return "Invalid Channel"
channels_info = {}
for channel_obj in channel_items:
if self.fhdhr.config.dict["epg"][
"images"] == "proxy" or not channel_obj.thumbnail:
logourl = ('%s/api/images?method=get&type=channel&id=%s' %
(base_url, str(channel_obj.dict['origin_id'])))
else:
logourl = channel_obj.thumbnail
channels_info[channel_obj.number] = {
"name": str(channel_obj.dict['name']),
"url": "%s%s" % (base_url, channel_obj.api_stream_url),
"epgId": str(channel_obj.dict['origin_id']),
"image": logourl,
}
# Sort the channels
sorted_channel_list = channel_sort(list(channels_info.keys()))
for channel in sorted_channel_list:
channel_info_w3u["stations"].append(channels_info[channel])
channels_info_json = json.dumps(channel_info_w3u, indent=4)
resp = Response(status=200,
response=channels_info_json,
mimetype='application/json')
resp.headers[
"content-disposition"] = "attachment; filename=%s" % fileName
return resp
return Response(status=200,
response=channels_info_json,
mimetype='application/json')
if redirect_url:
if "?" in redirect_url:
return redirect(
"%s&retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return redirect(
"%s?retmessage=%s" %
(redirect_url, urllib.parse.quote("%s Success" % method)))
else:
return "%s Success" % method
