radiomanifest.js/calendar.js

import ICAL from 'ical.js'
import shows from './shows'

function max(a, b) {
  if (a<b) return b
  return a
}

/**
 * Represent a schedule (ie: a .ics file)
 */
class RadioSchedule {
  constructor (calendar, radio) {
    this.calendar = calendar  // ICAL.Calendar
    this.radio = radio  // radiomanifest.Radio
  }

  /**
   * Get a list of all known {@link vEvent}s
   *
   * @returns {Array<external:ICAL~Component>}
   * */
  getEvents() {
    return this.calendar.getAllSubcomponents('vevent');

  }

  /**
   * @returns {RadioShow} tries to get a matching show, or create a new one
   */
  getShowByEvent(ev) {
    if (ev === null) return null
    if (this.radio !== undefined) {
      const showid = RadioSchedule.veventGetShowID(ev)
      var show = this.radio.getShowByName(showid)
      if (show === null || show === undefined) {
        return new shows.RadioShow(RadioSchedule.veventGetSummary(ev))
      }
      return show;
    }
    return new shows.RadioShow(RadioSchedule.veventGetSummary(ev))
  }

  /**
   * @returns {external:ICAL~Component} if nothing is going on right now, `null` is returned
   */
  getNowEvent(now) {
    var ev_now = this.getEvents().filter(function(vevent) {
      const ev = new ICAL.Event(vevent)
      return isNow(ev, now)
    })
    ev_now.sort((e1, e2) => { return this.veventGetPriority(e1) - this.veventGetPriority(e2) })
    if(ev_now.length === 0)
      return null
    return ev_now[0]
  }

  /**
   * @returns {RadioShow} if nothing is going on right now, `null` is returned
   */
  getNowShow(now) {
    const ev = this.getNowEvent(now)
    return this.getShowByEvent(ev)
  }

  /**
   * @returns {NextEvent} if there is none, `null` is returned
   */
  getNextEvent(now) {
    var nowEvent = this.getNowEvent(now)
    let future_events = this.getEvents().filter((e) => { return e != nowEvent })
      .map((e) => {
        const vEvent = new ICAL.Event(e)
        return {event: e, time: getNext(vEvent, now)}
      })
      .filter((x) => { return x.time !== null && x.time !== undefined })
    // since ".sort()" is guaranteed to be stable, we can sort by priority, then by date, so that two events
    // starting at the same time will be sorted observing priority
    future_events.sort((x1, x2) => this.veventGetPriority(x1.event) - this.veventGetPriority(x2.event))
    future_events.sort((x, y) => x.time.toUnixTime() - y.time.toUnixTime())

    if (future_events.length === 0) {
      return null
    }
    return future_events[0]
  }


  /**
   * @returns {NextShow} if there is no next show, null will be returned
   */
  getNextShow(now) {
    const next = this.getNextEvent(now)
    if (next === null) return null
    const ev = next.event
    const show = this.getShowByEvent(ev)
    return {show: show, time: next.time}
  }
  static veventGetSummary(vevent) {
      return vevent.getFirstProperty('summary').getFirstValue()
  }
  static veventGetShowID(vevent) {
      return RadioSchedule.veventGetSummary(vevent)  // XXX: X-Show-ID
  }

  /**
   * @return {integer} a normalized version of priority, easier to compare
   */
  veventGetPriority(ev) {
    const prop = ev.getFirstProperty('priority')
    let prio;
    if (prop === null) {
      prio = null
    } else {
      prio = prop.getFirstValue()
    }
    if (prio === null || prio === 0) {
      prio = 100
    }
    return prio
  }


}


function isNow(vEvent, now) {
    if (now === undefined) {
          now = ICAL.Time.now()
        }
    if (vEvent.isRecurring()) {
          return isNowRecurring(vEvent, now)
        }
    return (now < vEvent.endDate) && (now > vEvent.startDate);
}


function isNowRecurring(vEvent, now) {
  var expand = vEvent.iterator(vEvent.startDate)
  var next, next_end;

  while ((next = expand.next())) {
    next_end = next.clone()
    next_end.addDuration(vEvent.duration)

    if (next_end > now) {
      break;
    }
  }
  return (now < next_end && now > next);
}


/*
 * @private
 * @param {external:ICAL~Component} vEvent a _recurring_ vEvent
 * @param {external:ICAL~Time} [now]
 * @return {external:ICAL~Time} first future occurrence of this event
 */
function getNext(vEvent, now) {
  if (now === undefined) {
    now = ICAL.Time.now()
  }
  if (vEvent.isRecurring()) {
    return getNextRecurring(vEvent, now)
  }
  if (vEvent.endDate > now) {
    const val = max(now, vEvent.startDate)
    return val
  }
  return null
}

/*
 * @private
 * @param {external:ICAL~Component} vEvent a _recurring_ vEvent
 * @param {external:ICAL~Time} now
 * @return {external:ICAL~Time} first future occurrence of this event
 */
function getNextRecurring(vEvent, now) {
  var expand = vEvent.iterator(vEvent.startDate)
  var next, next_end;

  while ((next = expand.next())) {
    const start = next.clone()
    next_end = start.clone()
    next_end.addDuration(vEvent.duration)
    if (next_end <= now) {
      continue
    }
    return max(start, now)
  }
  return null
}


async function get(manifest) {
  if (manifest.scheduleURL) {
    let resp = null
    try {
      resp = await fetch(manifest.scheduleURL)
    } catch (e) {
      true
    }
    if (resp !== null) {
      try {
        const text = await resp.text()
        return parse(text)
      } catch (e) {
        console.error('Error while parsing schedule', e)
        throw e
      }
    }
  }
}

/**
 * Parse ICAL and get a RadioSchedule
 *
 * @param {string} text The text, in ICS format
 * @returns {RadioSchedule}
 */
function parse(text) {
  var jcalData = ICAL.parse(text);
  var vcalendar = new ICAL.Component(jcalData);

  return new RadioSchedule(vcalendar)
}


export default {
  get: get,
  parse: parse,
  RadioSchedule: RadioSchedule,
}

/**
 * @typedef {Object} NextShow
 * @property {RadioShow} show The next show scheduled
 * @property {external:ICAL~Time} time When it will start
 */

/**
 * @typedef {Object} NextEvent
 * @property {RadioShow} event The next show scheduled
 * @property {external:ICAL~Time} time When it will start
 */

/**
 * @external ICAL
 * @see https://mozilla-comm.github.io/ical.js/api/index.html
 */

/**
 * @class Component
 * @memberof external:ICAL
 * @inner
 * @see https://mozilla-comm.github.io/ical.js/api/ICAL.Component.html
 */

/**
 * @class Time
 * @memberof external:ICAL
 * @inner
 * @see https://mozilla-comm.github.io/ical.js/api/ICAL.Time.html
 */