mirror of
https://github.com/iptv-org/epg
synced 2026-09-06 12:00:09 -04:00
349 lines
10 KiB
JavaScript
349 lines
10 KiB
JavaScript
const axios = require('axios')
|
|
const dayjs = require('dayjs')
|
|
const doFetch = require('@ntlab/sfetch')
|
|
const debug = require('debug')('site:sky.com')
|
|
const fs = require('fs')
|
|
const path = require('path')
|
|
const utc = require('dayjs/plugin/utc')
|
|
|
|
dayjs.extend(utc)
|
|
|
|
doFetch.setCheckResult(false).setDebugger(debug)
|
|
|
|
const ATLANTIS_API_ENDPOINT = 'https://atlantis.epgsky.com/as'
|
|
const CHANNELS_FILE = path.join(__dirname, 'sky.com.channels.xml')
|
|
const HAWK_API_ENDPOINT = 'https://awk.epgsky.com/hawk/linear'
|
|
const LANG_BY_TERRITORY = {
|
|
DE: 'de',
|
|
GB: 'en',
|
|
IT: 'it'
|
|
}
|
|
const MAX_SIDS_PER_REQUEST = 20
|
|
const GRAB_START_DATE = dayjs.utc(process.env.CURR_DATE || new Date().toISOString()).startOf('d')
|
|
const eventIds = new Set()
|
|
const scheduleRequests = new Map()
|
|
let scheduleBatches
|
|
|
|
module.exports = {
|
|
site: 'sky.com',
|
|
days: 2,
|
|
request: {
|
|
headers({ channel }) {
|
|
const { territory } = parseSiteId(channel.site_id)
|
|
|
|
return isUhdChannel(channel) ? getAtlantisHeaders(territory) : getHeaders(territory)
|
|
},
|
|
cache: {
|
|
ttl: 24 * 60 * 60 * 1000, // 1 day
|
|
vary: ['X-SkyOTT-Territory']
|
|
}
|
|
},
|
|
url({ date, channel }) {
|
|
const { sid } = parseSiteId(channel.site_id)
|
|
if (isUhdChannel(channel)) {
|
|
return `${ATLANTIS_API_ENDPOINT}/schedule/${date.format('YYYYMMDD')}/${sid}`
|
|
}
|
|
|
|
const sids = getScheduleBatch(channel.site_id) || [sid]
|
|
|
|
return `${HAWK_API_ENDPOINT}/schedule/${date.format('YYYYMMDD')}/${sids.join(',')}`
|
|
},
|
|
async parser({ content, channel, date, config }) {
|
|
const programs = []
|
|
const events = new Map()
|
|
const range = getGrabRange(config)
|
|
|
|
collectEvents(content, channel, events)
|
|
|
|
date = date.startOf('d')
|
|
if (date.isSame(range.lastDate, 'd')) {
|
|
try {
|
|
const response = await getSchedule(channel, date.add(1, 'd'))
|
|
collectEvents(response, channel, events)
|
|
} catch (error) {
|
|
debug('Unable to load the final Sky schedule batch: %s', error.message)
|
|
}
|
|
}
|
|
|
|
for (const event of events.values()) {
|
|
const start = dayjs.utc(event.st * 1000)
|
|
const stop = start.add(event.d, 's')
|
|
const eventId = getEventId(channel, event)
|
|
if (
|
|
start.isBefore(range.stop) &&
|
|
stop.isAfter(range.start) &&
|
|
!eventIds.has(eventId)
|
|
) {
|
|
eventIds.add(eventId)
|
|
const image = event.programmeuuid
|
|
? `https://images.metadata.sky.com/pd-image/${event.programmeuuid}/16-9/640`
|
|
: null
|
|
|
|
programs.push({
|
|
title: event.t,
|
|
description: event.sy,
|
|
season: event.seasonnumber,
|
|
episode: event.episodenumber,
|
|
start,
|
|
stop,
|
|
icon: image,
|
|
image
|
|
})
|
|
}
|
|
}
|
|
|
|
return programs
|
|
},
|
|
async channels() {
|
|
const territories = Object.entries(LANG_BY_TERRITORY)
|
|
const queue = territories.map(([territory, lang]) => ({
|
|
type: 'regions',
|
|
lang,
|
|
territory,
|
|
url: `${HAWK_API_ENDPOINT}/regions`,
|
|
params: {
|
|
headers: getHeaders(territory)
|
|
}
|
|
}))
|
|
const channels = new Map()
|
|
const regions = new Set()
|
|
const failures = []
|
|
const states = new Map(
|
|
territories.map(([territory]) => [
|
|
territory,
|
|
{
|
|
channels: 0,
|
|
regionsLoaded: false,
|
|
serviceRequests: 0,
|
|
serviceResponses: 0
|
|
}
|
|
])
|
|
)
|
|
|
|
await doFetch(queue, (request, response) => {
|
|
const state = states.get(request.territory)
|
|
if (request.type === 'regions') {
|
|
if (!Array.isArray(response?.regions) || !response.regions.length) {
|
|
failures.push(`${request.territory}: ${request.url}`)
|
|
return
|
|
}
|
|
|
|
state.regionsLoaded = true
|
|
for (const region of response.regions) {
|
|
if (region?.bouquetId === undefined || region?.subBouquetId === undefined) {
|
|
failures.push(`${request.territory}: ${request.url} (invalid region)`)
|
|
continue
|
|
}
|
|
|
|
const regionId = `${region.bouquetId}/${region.subBouquetId}`
|
|
const key = `${request.territory}:${regionId}`
|
|
if (regions.has(key)) continue
|
|
|
|
regions.add(key)
|
|
const serviceRequests = [
|
|
{
|
|
source: 'hawk',
|
|
url: `${HAWK_API_ENDPOINT}/services/${regionId}`,
|
|
headers: getHeaders(request.territory)
|
|
},
|
|
{
|
|
source: 'atlantis',
|
|
url: `${ATLANTIS_API_ENDPOINT}/services/${regionId}`,
|
|
headers: getAtlantisHeaders(request.territory)
|
|
}
|
|
]
|
|
|
|
state.serviceRequests += serviceRequests.length
|
|
for (const serviceRequest of serviceRequests) {
|
|
queue.push({
|
|
type: 'services',
|
|
lang: request.lang,
|
|
source: serviceRequest.source,
|
|
territory: request.territory,
|
|
url: serviceRequest.url,
|
|
params: {
|
|
headers: serviceRequest.headers
|
|
}
|
|
})
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
if (!Array.isArray(response?.services)) {
|
|
failures.push(`${request.territory}: ${request.url}`)
|
|
return
|
|
}
|
|
|
|
state.serviceResponses++
|
|
for (const service of response.services) {
|
|
if (service?.sid === undefined) {
|
|
failures.push(`${request.territory}: ${request.url} (invalid service)`)
|
|
continue
|
|
}
|
|
|
|
if (!service.t) continue
|
|
if (request.source === 'atlantis' && service.schedule !== true) continue
|
|
|
|
const siteId = `${request.territory}#${service.sid}`
|
|
if (!channels.has(siteId) || request.source === 'hawk') {
|
|
const isNew = !channels.has(siteId)
|
|
channels.set(siteId, {
|
|
lang: request.lang,
|
|
site_id: siteId,
|
|
name: service.t
|
|
})
|
|
if (isNew) state.channels++
|
|
}
|
|
}
|
|
})
|
|
|
|
const incomplete = [...states]
|
|
.filter(
|
|
([, state]) =>
|
|
!state.regionsLoaded ||
|
|
!state.serviceRequests ||
|
|
state.serviceResponses !== state.serviceRequests ||
|
|
!state.channels
|
|
)
|
|
.map(([territory]) => territory)
|
|
|
|
if (incomplete.length || failures.length) {
|
|
const reasons = [...new Set([...failures, ...incomplete])].join(', ')
|
|
throw new Error(`Unable to load complete Sky channel list: ${reasons || 'no channels found'}`)
|
|
}
|
|
|
|
return [...channels.values()]
|
|
}
|
|
}
|
|
|
|
function getHeaders(territory) {
|
|
return {
|
|
'X-SkyOTT-Territory': territory
|
|
}
|
|
}
|
|
|
|
function getAtlantisHeaders(territory) {
|
|
return {
|
|
'X-SkyOTT-Proposition': 'SKYQ',
|
|
'X-SkyOTT-Provider': 'SKY',
|
|
...getHeaders(territory)
|
|
}
|
|
}
|
|
|
|
function getEventId(channel, event) {
|
|
return `${channel.site_id}:${event.eid}`
|
|
}
|
|
|
|
function getGrabRange(config) {
|
|
const configuredDays = Number(config?.days)
|
|
const days =
|
|
Number.isInteger(configuredDays) && configuredDays > 0 ? configuredDays : module.exports.days
|
|
const stop = GRAB_START_DATE.add(days, 'd')
|
|
|
|
return {
|
|
lastDate: stop.subtract(1, 'd'),
|
|
start: GRAB_START_DATE,
|
|
stop
|
|
}
|
|
}
|
|
|
|
function getSchedule(channel, date) {
|
|
const { territory } = parseSiteId(channel.site_id)
|
|
const url = module.exports.url({ channel, date })
|
|
const key = `${territory}:${url}`
|
|
|
|
if (!scheduleRequests.has(key)) {
|
|
const request = axios
|
|
.get(url, {
|
|
headers: module.exports.request.headers({ channel })
|
|
})
|
|
.then(response => response.data)
|
|
.catch(error => {
|
|
scheduleRequests.delete(key)
|
|
throw error
|
|
})
|
|
|
|
scheduleRequests.set(key, request)
|
|
}
|
|
|
|
return scheduleRequests.get(key)
|
|
}
|
|
|
|
function getScheduleBatch(siteId) {
|
|
if (!scheduleBatches) scheduleBatches = loadScheduleBatches()
|
|
|
|
return scheduleBatches.get(siteId)
|
|
}
|
|
|
|
function loadScheduleBatches() {
|
|
const channelsXml = fs.readFileSync(CHANNELS_FILE, 'utf8')
|
|
const sidsByTerritory = new Map(
|
|
Object.keys(LANG_BY_TERRITORY).map(territory => [territory, new Set()])
|
|
)
|
|
|
|
for (const match of channelsXml.matchAll(/<channel\b([^>]*)>([^<]*)<\/channel>/g)) {
|
|
const siteId = match[1].match(/\bsite_id="([^"]+)"/)?.[1]
|
|
if (!siteId || isUhdChannel({ name: match[2] })) continue
|
|
|
|
const { sid, territory } = parseSiteId(siteId)
|
|
sidsByTerritory.get(territory).add(sid)
|
|
}
|
|
|
|
const batches = new Map()
|
|
for (const [territory, sidSet] of sidsByTerritory) {
|
|
const sids = [...sidSet]
|
|
for (let index = 0; index < sids.length; index += MAX_SIDS_PER_REQUEST) {
|
|
const batch = sids.slice(index, index + MAX_SIDS_PER_REQUEST)
|
|
for (const sid of batch) {
|
|
batches.set(`${territory}#${sid}`, batch)
|
|
}
|
|
}
|
|
}
|
|
|
|
return batches
|
|
}
|
|
|
|
function collectEvents(content, channel, events) {
|
|
const data = parseContent(content)
|
|
if (!Array.isArray(data?.schedule)) return
|
|
|
|
const { sid } = parseSiteId(channel.site_id)
|
|
for (const schedule of data.schedule) {
|
|
if (String(schedule.sid) !== sid || !Array.isArray(schedule.events)) continue
|
|
|
|
for (const event of schedule.events) {
|
|
if (event?.eid !== undefined && !events.has(event.eid)) {
|
|
events.set(event.eid, event)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function isUhdChannel(channel) {
|
|
return /uhd|ultra\s*hd|4k/i.test(`${channel?.name || ''} ${channel?.xmltv_id || ''}`)
|
|
}
|
|
|
|
function parseSiteId(siteId) {
|
|
const [territory, sid, ...extra] = String(siteId || '').split('#')
|
|
if (!LANG_BY_TERRITORY[territory] || !sid || extra.length) {
|
|
throw new Error(
|
|
`Invalid Sky site_id "${siteId || ''}". Expected "<territory>#<sid>" with territory "DE", "GB" or "IT".`
|
|
)
|
|
}
|
|
|
|
return { sid, territory }
|
|
}
|
|
|
|
function parseContent(content) {
|
|
if (!content) return null
|
|
|
|
try {
|
|
if (Buffer.isBuffer(content)) content = content.toString()
|
|
|
|
return typeof content === 'string' ? JSON.parse(content) : content
|
|
} catch {
|
|
return null
|
|
}
|
|
}
|