Initial Commit

scripts/commands/channels/editor.js

@@ -0,0 +1,116 @@
+const { api, parser, xml, file, logger } = require('../../core')
+const { transliterate } = require('transliteration')
+const nodeCleanup = require('node-cleanup')
+const { program } = require('commander')
+const inquirer = require('inquirer')
+
+program
+  .requiredOption('-i, --input <file>', 'Load channels from the file')
+  .option('-c, --country <name>', 'Source country', 'us')
+  .parse(process.argv)
+
+const options = program.opts()
+const defaultCountry = options.country
+const newLabel = ` [new]`
+
+let site
+let channels = []
+
+async function main() {
+  let result = await parser.parseChannels(options.input)
+  site = result.site
+  channels = result.channels
+  channels = channels.map(c => {
+    c.xmltv_id = c.id
+    return c
+  })
+  await api.channels.load()
+  for (const channel of channels) {
+    if (channel.xmltv_id) continue
+    let choices = await getOptions(channel)
+    const question = {
+      name: 'option',
+      message: `Choose an option:`,
+      type: 'list',
+      choices,
+      pageSize: 10
+    }
+    await inquirer.prompt(question).then(async selected => {
+      switch (selected.option) {
+        case 'Overwrite...':
+          const input = await getInput(channel)
+          channel.xmltv_id = input.xmltv_id
+          break
+        case 'Skip...':
+          channel.xmltv_id = '-'
+          break
+        default:
+          const [name, xmltv_id] = selected.option
+            .replace(/ \[.*\]/, '')
+            .split('|')
+            .map(i => i.trim().replace(newLabel, ''))
+          channel.xmltv_id = xmltv_id
+          break
+      }
+    })
+  }
+}
+
+main()
+
+function save() {
+  const output = xml.create(channels, site)
+
+  file.writeSync(options.input, output)
+
+  logger.info(`\nFile '${options.input}' successfully saved`)
+}
+
+nodeCleanup(() => {
+  save()
+})
+
+async function getInput(channel) {
+  const name = channel.name.trim()
+  const input = await inquirer.prompt([
+    {
+      name: 'xmltv_id',
+      message: '  ID:',
+      type: 'input',
+      default: generateCode(name, defaultCountry)
+    }
+  ])
+
+  return { name, xmltv_id: input['xmltv_id'] }
+}
+
+async function getOptions(channel) {
+  const channels = await api.channels.all()
+  const channelId = generateCode(channel.name, defaultCountry)
+  const similar = await getSimilar(channels, channelId)
+  let variants = []
+  variants.push(`${channel.name.trim()} | ${channelId}${newLabel}`)
+  similar.forEach(i => {
+    let alt_names = i.alt_names.length ? ` (${i.alt_names.join(',')})` : ''
+    let closed = i.closed ? `[closed:${i.closed}]` : ``
+    let replaced_by = i.replaced_by ? `[replaced_by:${i.replaced_by}]` : ''
+    variants.push(`${i.name}${alt_names} | ${i.id} ${closed}${replaced_by}[api]`)
+  })
+  variants.push(`Overwrite...`)
+  variants.push(`Skip...`)
+
+  return variants
+}
+
+async function getSimilar(list, channelId) {
+  const normChannelId = channelId.split('.')[0].slice(0, 8).toLowerCase()
+  return list.filter(i => i.id.split('.')[0].toLowerCase().startsWith(normChannelId))
+}
+
+function generateCode(name, country) {
+  const id = transliterate(name)
+    .replace(/\+/gi, 'Plus')
+    .replace(/[^a-z\d]+/gi, '')
+
+  return `${id}.${country}`
+}

scripts/commands/channels/lint.js

@@ -0,0 +1,76 @@
+const chalk = require('chalk')
+const libxml = require('libxmljs2')
+const { program } = require('commander')
+const { logger, file } = require('../../core')
+
+const xsd = `<?xml version="1.0" encoding="UTF-8"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified">
+  <xs:element name="site">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element ref="channels"/>
+      </xs:sequence>
+      <xs:attribute name="site" use="required" type="xs:string"/>
+    </xs:complexType>
+  </xs:element>
+  <xs:element name="channels">
+    <xs:complexType>
+      <xs:sequence>
+        <xs:element minOccurs="0" maxOccurs="unbounded" ref="channel"/>
+      </xs:sequence>
+    </xs:complexType>
+  </xs:element>
+  <xs:element name="channel">
+    <xs:complexType mixed="true">
+      <xs:attribute name="lang" use="required" type="xs:string"/>
+      <xs:attribute name="site_id" use="required" type="xs:string"/>
+      <xs:attribute name="xmltv_id" use="required" type="xs:string"/>
+    </xs:complexType>
+  </xs:element>
+</xs:schema>`
+
+program.argument('<filepath>', 'Path to file to validate').parse(process.argv)
+
+async function main() {
+  if (!program.args.length) {
+    logger.error('required argument "filepath" not specified')
+  }
+
+  let errors = []
+
+  for (const filepath of program.args) {
+    if (!filepath.endsWith('.xml')) continue
+
+    const xml = await file.read(filepath)
+
+    let localErrors = []
+
+    try {
+      const xsdDoc = libxml.parseXml(xsd)
+      const doc = libxml.parseXml(xml)
+
+      if (!doc.validate(xsdDoc)) {
+        localErrors = doc.validationErrors
+      }
+    } catch (error) {
+      localErrors.push(error)
+    }
+
+    if (localErrors.length) {
+      logger.info(`\n${chalk.underline(filepath)}`)
+      localErrors.forEach(error => {
+        const position = `${error.line}:${error.column}`
+        logger.error(` ${chalk.gray(position.padEnd(4, ' '))} ${error.message.trim()}`)
+      })
+
+      errors = errors.concat(localErrors)
+    }
+  }
+
+  if (errors.length) {
+    logger.error(chalk.red(`\n${errors.length} error(s)`))
+    process.exit(1)
+  }
+}
+
+main()

scripts/commands/channels/parse.js

@@ -0,0 +1,48 @@
+const { logger, file, xml } = require('../../core')
+const { Command } = require('commander')
+const path = require('path')
+const _ = require('lodash')
+
+const program = new Command()
+program
+  .requiredOption('-c, --config <config>', 'Config file')
+  .option('-s, --set [args...]', 'Set custom arguments', [])
+  .option('-o, --output <output>', 'Output file')
+  .parse(process.argv)
+
+const options = program.opts()
+
+async function main() {
+  const config = require(path.resolve(options.config))
+  const args = {}
+  options.set.forEach(arg => {
+    const [key, value] = arg.split(':')
+    args[key] = value
+  })
+
+  let channels = config.channels(args)
+  if (isPromise(channels)) {
+    channels = await channels
+  }
+  channels = channels.map(c => {
+    c.lang = c.lang || 'en'
+
+    return c
+  })
+  channels = _.sortBy(channels, ['lang', 'xmltv_id'])
+
+  const dir = file.dirname(options.config)
+  const outputFilepath = options.output || `${dir}/${config.site}.channels.xml`
+
+  const output = xml.create(channels, config.site)
+
+  await file.write(outputFilepath, output)
+
+  logger.info(`File '${outputFilepath}' successfully saved`)
+}
+
+main()
+
+function isPromise(promise) {
+  return !!promise && typeof promise.then === 'function'
+}

scripts/commands/channels/validate.js

@@ -0,0 +1,68 @@
+const { parser, logger, api } = require('../../core')
+const { program } = require('commander')
+const chalk = require('chalk')
+const langs = require('langs')
+
+program.argument('<filepath>', 'Path to file to validate').parse(process.argv)
+
+async function main() {
+  await api.channels.load()
+
+  const stats = {
+    files: 0,
+    errors: 0
+  }
+
+  if (!program.args.length) {
+    logger.error('required argument "filepath" not specified')
+  }
+
+  for (const filepath of program.args) {
+    if (!filepath.endsWith('.xml')) continue
+
+    const { site, channels } = await parser.parseChannels(filepath)
+
+    const bufferById = {}
+    const bufferBySiteId = {}
+    const errors = []
+    for (const channel of channels) {
+      if (!bufferById[channel.id + channel.lang]) {
+        bufferById[channel.id + channel.lang] = channel
+      } else {
+        errors.push({ type: 'duplicate', xmltv_id: channel.id, ...channel })
+        stats.errors++
+      }
+
+      if (!bufferBySiteId[channel.site_id + channel.lang]) {
+        bufferBySiteId[channel.site_id + channel.lang] = channel
+      } else {
+        errors.push({ type: 'duplicate', xmltv_id: channel.id, ...channel })
+        stats.errors++
+      }
+
+      if (!api.channels.find({ id: channel.id })) {
+        errors.push({ type: 'wrong_xmltv_id', xmltv_id: channel.id, ...channel })
+        stats.errors++
+      }
+
+      if (!langs.where('1', channel.lang)) {
+        errors.push({ type: 'wrong_lang', xmltv_id: channel.id, ...channel })
+        stats.errors++
+      }
+    }
+
+    if (errors.length) {
+      logger.info(chalk.underline(filepath))
+      console.table(errors, ['type', 'lang', 'xmltv_id', 'site_id', 'name'])
+      console.log()
+      stats.files++
+    }
+  }
+
+  if (stats.errors > 0) {
+    logger.error(chalk.red(`${stats.errors} error(s) in ${stats.files} file(s)`))
+    process.exit(1)
+  }
+}
+
+main()