Update scripts

scripts/generators/categoriesGenerator.ts

@@ -29,11 +29,7 @@ export class CategoriesGenerator implements Generator {
       const categoryStreams = streams
         .filter((stream: Stream) => stream.hasCategory(category))
         .map((stream: Stream) => {
-          const streamCategories = stream.categories
-            .map((category: Category) => category.name)
-            .sort()
-          const groupTitle = stream.categories ? streamCategories.join(';') : ''
-          stream.groupTitle = groupTitle
+          stream.groupTitle = stream.getCategoryNames().join(';')
 
           return stream
         })
@@ -41,13 +37,17 @@ export class CategoriesGenerator implements Generator {
       const playlist = new Playlist(categoryStreams, { public: true })
       const filepath = `categories/${category.id}.m3u`
       await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+      this.logger.info(
+        JSON.stringify({ type: 'category', filepath, count: playlist.streams.count() })
+      )
     })
 
-    const undefinedStreams = streams.filter((stream: Stream) => stream.noCategories())
+    const undefinedStreams = streams.filter((stream: Stream) => !stream.hasCategories())
     const playlist = new Playlist(undefinedStreams, { public: true })
     const filepath = 'categories/undefined.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    this.logger.info(
+      JSON.stringify({ type: 'category', filepath, count: playlist.streams.count() })
+    )
   }
 }

scripts/generators/countriesGenerator.ts

@@ -1,12 +1,10 @@
 import { Generator } from './generator'
 import { Collection, Storage, Logger } from '@freearhey/core'
-import { Country, Region, Subdivision, Stream, Playlist } from '../models'
+import { Country, Subdivision, Stream, Playlist } from '../models'
 import { PUBLIC_DIR } from '../constants'
 
 type CountriesGeneratorProps = {
   streams: Collection
-  regions: Collection
-  subdivisions: Collection
   countries: Collection
   logger: Logger
 }
@@ -14,55 +12,37 @@ type CountriesGeneratorProps = {
 export class CountriesGenerator implements Generator {
   streams: Collection
   countries: Collection
-  regions: Collection
-  subdivisions: Collection
   storage: Storage
   logger: Logger
 
-  constructor({ streams, countries, regions, subdivisions, logger }: CountriesGeneratorProps) {
+  constructor({ streams, countries, logger }: CountriesGeneratorProps) {
     this.streams = streams
     this.countries = countries
-    this.regions = regions
-    this.subdivisions = subdivisions
     this.storage = new Storage(PUBLIC_DIR)
     this.logger = logger
   }
 
   async generate(): Promise<void> {
     const streams = this.streams
-      .orderBy([stream => stream.getTitle()])
+      .orderBy((stream: Stream) => stream.getTitle())
       .filter((stream: Stream) => stream.isSFW())
-    const regions = this.regions.filter((region: Region) => region.code !== 'INT')
 
     this.countries.forEach(async (country: Country) => {
-      const countrySubdivisions = this.subdivisions.filter(
-        (subdivision: Subdivision) => subdivision.country === country.code
+      const countryStreams = streams.filter((stream: Stream) =>
+        stream.isBroadcastInCountry(country)
       )
-
-      const countrySubdivisionsCodes = countrySubdivisions.map(
-        (subdivision: Subdivision) => `s/${subdivision.code}`
-      )
-
-      const countryAreaCodes = regions
-        .filter((region: Region) => region.countries.includes(country.code))
-        .map((region: Region) => `r/${region.code}`)
-        .concat(countrySubdivisionsCodes)
-        .add(`c/${country.code}`)
-
-      const countryStreams = streams.filter(stream =>
-        stream.broadcastArea.intersects(countryAreaCodes)
-      )
-
       if (countryStreams.isEmpty()) return
 
       const playlist = new Playlist(countryStreams, { public: true })
       const filepath = `countries/${country.code.toLowerCase()}.m3u`
       await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+      this.logger.info(
+        JSON.stringify({ type: 'country', filepath, count: playlist.streams.count() })
+      )
 
-      countrySubdivisions.forEach(async (subdivision: Subdivision) => {
-        const subdivisionStreams = streams.filter(stream =>
-          stream.broadcastArea.includes(`s/${subdivision.code}`)
+      country.getSubdivisions().forEach(async (subdivision: Subdivision) => {
+        const subdivisionStreams = streams.filter((stream: Stream) =>
+          stream.isBroadcastInSubdivision(subdivision)
         )
 
         if (subdivisionStreams.isEmpty()) return
@@ -70,16 +50,22 @@ export class CountriesGenerator implements Generator {
         const playlist = new Playlist(subdivisionStreams, { public: true })
         const filepath = `subdivisions/${subdivision.code.toLowerCase()}.m3u`
         await this.storage.save(filepath, playlist.toString())
-        this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+        this.logger.info(
+          JSON.stringify({ type: 'subdivision', filepath, count: playlist.streams.count() })
+        )
       })
     })
 
-    const internationalStreams = streams.filter(stream => stream.isInternational())
-    if (internationalStreams.notEmpty()) {
-      const playlist = new Playlist(internationalStreams, { public: true })
-      const filepath = 'countries/int.m3u'
-      await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-    }
+    const undefinedStreams = streams.filter((stream: Stream) => !stream.hasBroadcastArea())
+    const undefinedPlaylist = new Playlist(undefinedStreams, { public: true })
+    const undefinedFilepath = 'countries/undefined.m3u'
+    await this.storage.save(undefinedFilepath, undefinedPlaylist.toString())
+    this.logger.info(
+      JSON.stringify({
+        type: 'country',
+        filepath: undefinedFilepath,
+        count: undefinedPlaylist.streams.count()
+      })
+    )
   }
 }

scripts/generators/indexCategoryGenerator.ts

@@ -26,14 +26,14 @@ export class IndexCategoryGenerator implements Generator {
 
     let groupedStreams = new Collection()
     streams.forEach((stream: Stream) => {
-      if (stream.noCategories()) {
+      if (!stream.hasCategories()) {
         const streamClone = stream.clone()
         streamClone.groupTitle = 'Undefined'
         groupedStreams.add(streamClone)
         return
       }
 
-      stream.categories.forEach((category: Category) => {
+      stream.getCategories().forEach((category: Category) => {
         const streamClone = stream.clone()
         streamClone.groupTitle = category.name
         groupedStreams.push(streamClone)
@@ -48,6 +48,6 @@ export class IndexCategoryGenerator implements Generator {
     const playlist = new Playlist(groupedStreams, { public: true })
     const filepath = 'index.category.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    this.logger.info(JSON.stringify({ type: 'index', filepath, count: playlist.streams.count() }))
   }
 }

scripts/generators/indexCountryGenerator.ts

@@ -1,29 +1,20 @@
 import { Generator } from './generator'
 import { Collection, Storage, Logger } from '@freearhey/core'
-import { Stream, Playlist, Country, Subdivision, Region } from '../models'
+import { Stream, Playlist, Country } from '../models'
 import { PUBLIC_DIR } from '../constants'
 
 type IndexCountryGeneratorProps = {
   streams: Collection
-  regions: Collection
-  countries: Collection
-  subdivisions: Collection
   logger: Logger
 }
 
 export class IndexCountryGenerator implements Generator {
   streams: Collection
-  countries: Collection
-  regions: Collection
-  subdivisions: Collection
   storage: Storage
   logger: Logger
 
-  constructor({ streams, regions, countries, subdivisions, logger }: IndexCountryGeneratorProps) {
+  constructor({ streams, logger }: IndexCountryGeneratorProps) {
     this.streams = streams
-    this.countries = countries
-    this.regions = regions
-    this.subdivisions = subdivisions
     this.storage = new Storage(PUBLIC_DIR)
     this.logger = logger
   }
@@ -32,10 +23,10 @@ export class IndexCountryGenerator implements Generator {
     let groupedStreams = new Collection()
 
     this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
-      .forEach(stream => {
-        if (stream.noBroadcastArea()) {
+      .orderBy((stream: Stream) => stream.getTitle())
+      .filter((stream: Stream) => stream.isSFW())
+      .forEach((stream: Stream) => {
+        if (!stream.hasBroadcastArea()) {
           const streamClone = stream.clone()
           streamClone.groupTitle = 'Undefined'
           groupedStreams.add(streamClone)
@@ -48,7 +39,7 @@ export class IndexCountryGenerator implements Generator {
           groupedStreams.add(streamClone)
         }
 
-        this.getStreamBroadcastCountries(stream).forEach((country: Country) => {
+        stream.getBroadcastCountries().forEach((country: Country) => {
           const streamClone = stream.clone()
           streamClone.groupTitle = country.name
           groupedStreams.add(streamClone)
@@ -65,40 +56,6 @@ export class IndexCountryGenerator implements Generator {
     const playlist = new Playlist(groupedStreams, { public: true })
     const filepath = 'index.country.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-
-  getStreamBroadcastCountries(stream: Stream) {
-    const groupedRegions = this.regions.keyBy((region: Region) => region.code)
-    const groupedCountries = this.countries.keyBy((country: Country) => country.code)
-    const groupedSubdivisions = this.subdivisions.keyBy(
-      (subdivision: Subdivision) => subdivision.code
-    )
-
-    let broadcastCountries = new Collection()
-
-    stream.broadcastArea.forEach(broadcastAreaCode => {
-      const [type, code] = broadcastAreaCode.split('/')
-      switch (type) {
-        case 'c':
-          broadcastCountries.add(code)
-          break
-        case 'r':
-          if (code !== 'INT' && groupedRegions.has(code)) {
-            broadcastCountries = broadcastCountries.concat(groupedRegions.get(code).countries)
-          }
-          break
-        case 's':
-          if (groupedSubdivisions.has(code)) {
-            broadcastCountries.add(groupedSubdivisions.get(code).country)
-          }
-          break
-      }
-    })
-
-    return broadcastCountries
-      .uniq()
-      .map(code => groupedCountries.get(code))
-      .filter(Boolean)
+    this.logger.info(JSON.stringify({ type: 'index', filepath, count: playlist.streams.count() }))
   }
 }

scripts/generators/indexGenerator.ts

@@ -27,6 +27,6 @@ export class IndexGenerator implements Generator {
     const playlist = new Playlist(sfwStreams, { public: true })
     const filepath = 'index.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    this.logger.info(JSON.stringify({ type: 'index', filepath, count: playlist.streams.count() }))
   }
 }

scripts/generators/indexLanguageGenerator.ts

@@ -22,17 +22,17 @@ export class IndexLanguageGenerator implements Generator {
   async generate(): Promise<void> {
     let groupedStreams = new Collection()
     this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
-      .forEach(stream => {
-        if (stream.noLanguages()) {
+      .orderBy((stream: Stream) => stream.getTitle())
+      .filter((stream: Stream) => stream.isSFW())
+      .forEach((stream: Stream) => {
+        if (!stream.hasLanguages()) {
           const streamClone = stream.clone()
           streamClone.groupTitle = 'Undefined'
           groupedStreams.add(streamClone)
           return
         }
 
-        stream.languages.forEach((language: Language) => {
+        stream.getLanguages().forEach((language: Language) => {
           const streamClone = stream.clone()
           streamClone.groupTitle = language.name
           groupedStreams.add(streamClone)
@@ -47,6 +47,6 @@ export class IndexLanguageGenerator implements Generator {
     const playlist = new Playlist(groupedStreams, { public: true })
     const filepath = 'index.language.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    this.logger.info(JSON.stringify({ type: 'index', filepath, count: playlist.streams.count() }))
   }
 }

scripts/generators/indexNsfwGenerator.ts

@@ -25,6 +25,6 @@ export class IndexNsfwGenerator implements Generator {
     const playlist = new Playlist(allStreams, { public: true })
     const filepath = 'index.nsfw.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    this.logger.info(JSON.stringify({ type: 'index', filepath, count: playlist.streams.count() }))
   }
 }

scripts/generators/indexRegionGenerator.ts

@@ -28,14 +28,14 @@ export class IndexRegionGenerator implements Generator {
       .orderBy((stream: Stream) => stream.getTitle())
       .filter((stream: Stream) => stream.isSFW())
       .forEach((stream: Stream) => {
-        if (stream.noBroadcastArea()) {
+        if (!stream.hasBroadcastArea()) {
           const streamClone = stream.clone()
           streamClone.groupTitle = 'Undefined'
           groupedStreams.push(streamClone)
           return
         }
 
-        this.getStreamRegions(stream).forEach((region: Region) => {
+        stream.getBroadcastRegions().forEach((region: Region) => {
           const streamClone = stream.clone()
           streamClone.groupTitle = region.name
           groupedStreams.push(streamClone)
@@ -50,34 +50,6 @@ export class IndexRegionGenerator implements Generator {
     const playlist = new Playlist(groupedStreams, { public: true })
     const filepath = 'index.region.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
-  }
-
-  getStreamRegions(stream: Stream) {
-    let streamRegions = new Collection()
-    stream.broadcastArea.forEach(broadcastAreaCode => {
-      const [type, code] = broadcastAreaCode.split('/')
-      switch (type) {
-        case 'r':
-          const groupedRegions = this.regions.keyBy((region: Region) => region.code)
-          streamRegions.add(groupedRegions.get(code))
-          break
-        case 's':
-          const [countryCode] = code.split('-')
-          const subdivisionRegions = this.regions.filter((region: Region) =>
-            region.countries.includes(countryCode)
-          )
-          streamRegions = streamRegions.concat(subdivisionRegions)
-          break
-        case 'c':
-          const countryRegions = this.regions.filter((region: Region) =>
-            region.countries.includes(code)
-          )
-          streamRegions = streamRegions.concat(countryRegions)
-          break
-      }
-    })
-
-    return streamRegions
+    this.logger.info(JSON.stringify({ type: 'index', filepath, count: playlist.streams.count() }))
   }
 }

scripts/generators/languagesGenerator.ts

@@ -18,35 +18,40 @@ export class LanguagesGenerator implements Generator {
 
   async generate(): Promise<void> {
     const streams = this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
+      .orderBy((stream: Stream) => stream.getTitle())
+      .filter((stream: Stream) => stream.isSFW())
 
     let languages = new Collection()
     streams.forEach((stream: Stream) => {
-      languages = languages.concat(stream.languages)
+      languages = languages.concat(stream.getLanguages())
     })
 
     languages
+      .filter(Boolean)
       .uniqBy((language: Language) => language.code)
       .orderBy((language: Language) => language.name)
       .forEach(async (language: Language) => {
-        const languageStreams = streams.filter(stream => stream.hasLanguage(language))
+        const languageStreams = streams.filter((stream: Stream) => stream.hasLanguage(language))
 
         if (languageStreams.isEmpty()) return
 
         const playlist = new Playlist(languageStreams, { public: true })
         const filepath = `languages/${language.code}.m3u`
         await this.storage.save(filepath, playlist.toString())
-        this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+        this.logger.info(
+          JSON.stringify({ type: 'language', filepath, count: playlist.streams.count() })
+        )
       })
 
-    const undefinedStreams = streams.filter(stream => stream.noLanguages())
+    const undefinedStreams = streams.filter((stream: Stream) => !stream.hasLanguages())
 
     if (undefinedStreams.isEmpty()) return
 
     const playlist = new Playlist(undefinedStreams, { public: true })
     const filepath = 'languages/undefined.m3u'
     await this.storage.save(filepath, playlist.toString())
-    this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+    this.logger.info(
+      JSON.stringify({ type: 'language', filepath, count: playlist.streams.count() })
+    )
   }
 }

scripts/generators/regionsGenerator.ts

@@ -1,53 +1,61 @@
 import { Generator } from './generator'
 import { Collection, Storage, Logger } from '@freearhey/core'
-import { Playlist, Subdivision, Region } from '../models'
+import { Playlist, Region, Stream } from '../models'
 import { PUBLIC_DIR } from '../constants'
 
 type RegionsGeneratorProps = {
   streams: Collection
   regions: Collection
-  subdivisions: Collection
   logger: Logger
 }
 
 export class RegionsGenerator implements Generator {
   streams: Collection
   regions: Collection
-  subdivisions: Collection
   storage: Storage
   logger: Logger
 
-  constructor({ streams, regions, subdivisions, logger }: RegionsGeneratorProps) {
+  constructor({ streams, regions, logger }: RegionsGeneratorProps) {
     this.streams = streams
     this.regions = regions
-    this.subdivisions = subdivisions
     this.storage = new Storage(PUBLIC_DIR)
     this.logger = logger
   }
 
   async generate(): Promise<void> {
     const streams = this.streams
-      .orderBy(stream => stream.getTitle())
-      .filter(stream => stream.isSFW())
+      .orderBy((stream: Stream) => stream.getTitle())
+      .filter((stream: Stream) => stream.isSFW())
 
     this.regions.forEach(async (region: Region) => {
-      if (region.code === 'INT') return
+      if (region.isWorldwide()) return
 
-      const regionSubdivisionsCodes = this.subdivisions
-        .filter((subdivision: Subdivision) => region.countries.indexOf(subdivision.country) > -1)
-        .map((subdivision: Subdivision) => `s/${subdivision.code}`)
-
-      const regionCodes = region.countries
-        .map((code: string) => `c/${code}`)
-        .concat(regionSubdivisionsCodes)
-        .add(`r/${region.code}`)
-
-      const regionStreams = streams.filter(stream => stream.broadcastArea.intersects(regionCodes))
+      const regionStreams = streams.filter((stream: Stream) => stream.isBroadcastInRegion(region))
 
       const playlist = new Playlist(regionStreams, { public: true })
       const filepath = `regions/${region.code.toLowerCase()}.m3u`
       await this.storage.save(filepath, playlist.toString())
-      this.logger.info(JSON.stringify({ filepath, count: playlist.streams.count() }))
+      this.logger.info(
+        JSON.stringify({ type: 'region', filepath, count: playlist.streams.count() })
+      )
     })
+
+    const internationalStreams = streams.filter((stream: Stream) => stream.isInternational())
+    const internationalPlaylist = new Playlist(internationalStreams, { public: true })
+    const internationalFilepath = 'regions/int.m3u'
+    await this.storage.save(internationalFilepath, internationalPlaylist.toString())
+    this.logger.info(
+      JSON.stringify({
+        type: 'region',
+        filepath: internationalFilepath,
+        count: internationalPlaylist.streams.count()
+      })
+    )
+
+    const undefinedStreams = streams.filter((stream: Stream) => !stream.hasBroadcastArea())
+    const playlist = new Playlist(undefinedStreams, { public: true })
+    const filepath = 'regions/undefined.m3u'
+    await this.storage.save(filepath, playlist.toString())
+    this.logger.info(JSON.stringify({ type: 'region', filepath, count: playlist.streams.count() }))
   }
 }