From 36bccafc8ee3ec505b5e3d656c04ee2e6497bf27 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 11 Aug 2018 16:56:59 -0700 Subject: [PATCH 001/182] Extend m3u.Track to return line number and raw line --- m3u/main.go | 19 ++++++++++++------- 1 file changed, 12 insertions(+), 7 deletions(-) diff --git a/m3u/main.go b/m3u/main.go index ee33ce7..5aa449f 100644 --- a/m3u/main.go +++ b/m3u/main.go @@ -18,10 +18,12 @@ type Playlist struct { // Track represents an m3u track type Track struct { - Name string - Length float64 - URI string - Tags map[string]string + Name string + Length float64 + URI string + Tags map[string]string + Raw string + LineNumber int } // UnmarshalTags will decode the Tags map into a struct containing fields with `m3u` tags matching map keys. @@ -72,19 +74,22 @@ func decode(playlist *Playlist, buf *bytes.Buffer) error { return fmt.Errorf("malformed M3U provided") } - if err = decodeLine(playlist, line); err != nil { + if err = decodeLine(playlist, line, lineNum); err != nil { return err } } return nil } -func decodeLine(playlist *Playlist, line string) error { +func decodeLine(playlist *Playlist, line string, lineNumber int) error { line = strings.TrimSpace(line) switch { case strings.HasPrefix(line, "#EXTINF:"): - track := new(Track) + track := &Track{ + Raw: line, + LineNumber: lineNumber, + } track.Length, track.Name, track.Tags = decodeInfoLine(line) From a1948f2d496ac7ef6a4be3d976eb526cf66ed7f0 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 11 Aug 2018 23:28:31 -0700 Subject: [PATCH 002/182] Checkpoint on internal overhaul of playlist/tracks/lineup/channels. --- lineup.go | 247 +++++++++++++++++++++++++++++++++++++++++++++++++++++ main.go | 132 +++++++--------------------- routes.go | 24 ++++-- structs.go | 53 ++++++------ 4 files changed, 323 insertions(+), 133 deletions(-) create mode 100644 lineup.go diff --git a/lineup.go b/lineup.go new file mode 100644 index 0000000..9d6747a --- /dev/null +++ b/lineup.go @@ -0,0 +1,247 @@ +package main + +import ( + "encoding/base64" + "fmt" + "io" + "net/http" + "os" + "strings" + "time" + + "github.com/tombowditch/telly/m3u" +) + +// Track describes a single M3U segment. This struct includes m3u.Track as well as specific IPTV fields we want to get. +type Track struct { + *m3u.Track + SafeURI string `json:"URI"` + Catchup string `m3u:"catchup" json:",omitempty"` + CatchupDays string `m3u:"catchup-days" json:",omitempty"` + CatchupSource string `m3u:"catchup-source" json:",omitempty"` + GroupTitle string `m3u:"group-title" json:",omitempty"` + TvgID string `m3u:"tvg-id" json:",omitempty"` + TvgLogo string `m3u:"tvg-logo" json:",omitempty"` + TvgName string `m3u:"tvg-name" json:",omitempty"` +} + +// Channel returns a Channel struct for the given Track. +func (t *Track) Channel(number int, obfuscate bool) *HDHomeRunChannel { + var finalName string + if t.TvgName == "" { + finalName = t.Name + } else { + finalName = t.TvgName + } + + // base64 url + fullTrackURI := t.URI + if obfuscate { + trackURI := base64.StdEncoding.EncodeToString([]byte(t.URI)) + fullTrackURI = fmt.Sprintf("http://%s/stream/%s", opts.BaseAddress.String(), trackURI) + } + + // if strings.Contains(t.URI, ".m3u8") { + // log.Warnln("your .m3u contains .m3u8's. Plex has either stopped supporting m3u8 or it is a bug in a recent version - please use .ts! telly will automatically convert these in a future version. See telly github issue #108") + // } + + hd := false + if strings.Contains(strings.ToLower(t.Track.Raw), "hd") { + hd = true + } + + return &HDHomeRunChannel{ + GuideNumber: number, + GuideName: finalName, + URL: fullTrackURI, + HD: convertibleBoolean(hd), + + track: t, + } +} + +// Playlist describes a single M3U playlist. +type Playlist struct { + *m3u.Playlist + *M3UFile + + Tracks []Track + Channels []HDHomeRunChannel + TracksCount int + FilteredTracksCount int +} + +// Filter will filter the raw m3u.Playlist m3u.Track slice into the Track slice of the Playlist. +func (p *Playlist) Filter() error { + for _, oldTrack := range p.Playlist.Tracks { + track := Track{ + Track: oldTrack, + SafeURI: safeStringsRegex.ReplaceAllStringFunc(oldTrack.URI, stringSafer), + } + if unmarshalErr := oldTrack.UnmarshalTags(&track); unmarshalErr != nil { + return unmarshalErr + } + + if opts.Regex.MatchString(track.Name) == opts.RegexInclusive { + p.Tracks = append(p.Tracks, track) + } + } + + return nil +} + +// M3UFile describes a path and transport to a M3U provided in the configuration. +type M3UFile struct { + Path string `json:"-"` + SafePath string `json:"Path"` + Transport string +} + +// HDHomeRunChannel is a single channel found in the playlist. +type HDHomeRunChannel struct { + // These fields match what HDHomeRun uses and Plex expects to see. + AudioCodec string `json:",omitempty"` + DRM convertibleBoolean `json:",string,omitempty"` + Favorite convertibleBoolean `json:",string,omitempty"` + GuideName string `json:",omitempty"` + GuideNumber int `json:",string,omitempty"` + HD convertibleBoolean `json:",string,omitempty"` + URL string `json:",omitempty"` + VideoCodec string `json:",omitempty"` + + track *Track +} + +// Lineup is a collection of tracks +type Lineup struct { + Playlists []Playlist + PlaylistsCount int + TracksCount int + FilteredTracksCount int + + StartingChannelNumber int + channelNumber int + ObfuscateURL bool + + Refreshing bool + LastRefreshed time.Time `json:",omitempty"` +} + +// NewLineup returns a new Lineup for the given config struct. +func NewLineup(opts config) *Lineup { + return &Lineup{ + StartingChannelNumber: opts.StartingChannel, + channelNumber: opts.StartingChannel, + ObfuscateURL: !opts.DirectMode, + Refreshing: true, + LastRefreshed: time.Now(), + } +} + +// AddPlaylist adds a new playlist to the Lineup. +func (l *Lineup) AddPlaylist(path string) error { + reader, info, readErr := l.getM3U(path) + if readErr != nil { + log.WithError(readErr).Errorln("error getting m3u") + return readErr + } + + rawPlaylist, err := m3u.Decode(reader) + if err != nil { + log.WithError(err).Errorln("unable to parse m3u file") + return err + } + + playlist, playlistErr := l.NewPlaylist(rawPlaylist, info) + if playlistErr != nil { + return playlistErr + } + + l.Playlists = append(l.Playlists, *playlist) + l.TracksCount = l.TracksCount + playlist.TracksCount + l.FilteredTracksCount = l.FilteredTracksCount + playlist.FilteredTracksCount + + return nil +} + +// NewPlaylist will return a new and filtered Playlist for the given m3u.Playlist and M3UFile. +func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile) (*Playlist, error) { + playlist := &Playlist{rawPlaylist, info, nil, nil, len(rawPlaylist.Tracks), 0} + + if filterErr := playlist.Filter(); filterErr != nil { + log.WithError(filterErr).Errorln("error during filtering of channels, check your regex and try again") + return nil, filterErr + } + + for _, track := range playlist.Tracks { + + channel := track.Channel(l.channelNumber, l.ObfuscateURL) + + playlist.Channels = append(playlist.Channels, *channel) + + l.channelNumber = l.channelNumber + 1 + } + + playlist.FilteredTracksCount = len(playlist.Tracks) + exposedChannels.Add(float64(playlist.FilteredTracksCount)) + log.Debugf("Added %d channels to the lineup", playlist.FilteredTracksCount) + + return playlist, nil +} + +// Refresh will rescan all playlists for any channel changes. +func (l *Lineup) Refresh() error { + + log.Warnln("Refreshing the lineup!") + + l.Refreshing = true + + existingPlaylists := make([]Playlist, len(l.Playlists)) + copy(existingPlaylists, l.Playlists) + + l.Playlists = nil + l.TracksCount = 0 + l.FilteredTracksCount = 0 + l.StartingChannelNumber = 0 + + for _, playlist := range existingPlaylists { + if addErr := l.AddPlaylist(playlist.M3UFile.Path); addErr != nil { + return addErr + } + } + + l.LastRefreshed = time.Now() + l.Refreshing = false + + return nil +} + +func (l *Lineup) getM3U(path string) (io.Reader, *M3UFile, error) { + safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + log.Infof("Loading M3U from %s", safePath) + + info := &M3UFile{ + Path: path, + SafePath: safePath, + Transport: "disk", + } + + if strings.HasPrefix(strings.ToLower(path), "http") { + resp, err := http.Get(path) + if err != nil { + return nil, nil, err + } + //defer resp.Body.Close() + + info.Transport = "http" + + return resp.Body, info, nil + } + + file, fileErr := os.Open(path) + if fileErr != nil { + return nil, nil, fileErr + } + + return file, info, nil +} diff --git a/main.go b/main.go index b31a288..8b0ba1a 100644 --- a/main.go +++ b/main.go @@ -1,18 +1,13 @@ package main import ( - "encoding/base64" "fmt" - "io" - "net/http" - "os" - "strconv" + "regexp" "strings" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/common/version" "github.com/sirupsen/logrus" - "github.com/tombowditch/telly/m3u" kingpin "gopkg.in/alecthomas/kingpin.v2" ) @@ -27,6 +22,23 @@ var ( Help: "Number of exposed channels.", }, ) + + safeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) + + stringSafer = func(input string) string { + ret := input + if strings.HasPrefix(input, "username=") { + ret = "username=hunter1" + } else if strings.HasPrefix(input, "password=") { + ret = "password=hunter2" + } else if strings.HasPrefix(input, "token=") { + ret = "token=bm90Zm9yeW91" // "notforyou" + } + if strings.HasSuffix(input, "&") { + return fmt.Sprintf("%s&", ret) + } + return ret + } ) func main() { @@ -54,7 +66,7 @@ func main() { kingpin.Flag("log.requests", "Log HTTP requests $(TELLY_LOG_REQUESTS)").Envar("TELLY_LOG_REQUESTS").Default("false").BoolVar(&opts.LogRequests) // IPTV flags - kingpin.Flag("iptv.playlist", "Location of playlist M3U file. Can be on disk or a URL. $(TELLY_IPTV_PLAYLIST)").Envar("TELLY_IPTV_PLAYLIST").Default("iptv.m3u").StringVar(&opts.M3UPath) + kingpin.Flag("iptv.playlist", "Location of playlist M3U file. Can be on disk or a URL. $(TELLY_IPTV_PLAYLIST)").Envar("TELLY_IPTV_PLAYLIST").Default("iptv.m3u").StringsVar(&opts.Playlists) kingpin.Flag("iptv.streams", "Number of concurrent streams allowed $(TELLY_IPTV_STREAMS)").Envar("TELLY_IPTV_STREAMS").Default("1").IntVar(&opts.ConcurrentStreams) kingpin.Flag("iptv.direct", "If true, stream URLs will not be obfuscated to hide them from Plex. $(TELLY_IPTV_DIRECT)").Envar("TELLY_IPTV_DIRECT").Default("false").BoolVar(&opts.DirectMode) kingpin.Flag("iptv.starting-channel", "The channel number to start exposing from. $(TELLY_IPTV_STARTING_CHANNEL)").Envar("TELLY_IPTV_STARTING_CHANNEL").Default("10000").IntVar(&opts.StartingChannel) @@ -74,6 +86,7 @@ func main() { } log.SetLevel(level) + opts.FriendlyName = fmt.Sprintf("HDHomerun (%s)", opts.FriendlyName) opts.DeviceUUID = fmt.Sprintf("%d-AE2A-4E54-BBC9-33AF7D5D6A92", opts.DeviceID) if opts.BaseAddress.IP.IsUnspecified() { @@ -84,110 +97,23 @@ func main() { log.Warnln("You are listening on all interfaces but your base URL is localhost (meaning Plex will try and load localhost to access your streams) - is this intended?") } - if opts.M3UPath == "iptv.m3u" { + if len(opts.Playlists) == 1 && opts.Playlists[0] == "iptv.m3u" { log.Warnln("using default m3u option, 'iptv.m3u'. launch telly with the --iptv.playlist=yourfile.m3u option to change this!") } - m3uReader, readErr := getM3U(opts) - if readErr != nil { - log.WithError(readErr).Panicln("error getting m3u") - } - - playlist, err := m3u.Decode(m3uReader) - if err != nil { - log.WithError(err).Panicln("unable to parse m3u file") - } - - channels, filterErr := filterTracks(playlist.Tracks) - if filterErr != nil { - log.WithError(filterErr).Panicln("error during filtering of channels, check your regex and try again") - } - - log.Debugln("Building lineup") - - opts.lineup = buildLineup(opts, channels) - - channelCount := len(channels) - exposedChannels.Set(float64(channelCount)) - log.Infof("found %d channels", channelCount) - - if channelCount > 420 { - log.Warnln("telly has loaded more than 420 channels. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You have been warned!") - } - - opts.FriendlyName = fmt.Sprintf("HDHomerun (%s)", opts.FriendlyName) - - serve(opts) -} - -func buildLineup(opts config, channels []Track) []LineupItem { - lineup := make([]LineupItem, 0) - gn := opts.StartingChannel - - for _, track := range channels { - - var finalName string - if track.TvgName == "" { - finalName = track.Name - } else { - finalName = track.TvgName - } - - // base64 url - fullTrackURI := track.URI - if !opts.DirectMode { - trackURI := base64.StdEncoding.EncodeToString([]byte(track.URI)) - fullTrackURI = fmt.Sprintf("http://%s/stream/%s", opts.BaseAddress.String(), trackURI) - } - - if strings.Contains(track.URI, ".m3u8") { - log.Warnln("your .m3u contains .m3u8's. Plex has either stopped supporting m3u8 or it is a bug in a recent version - please use .ts! telly will automatically convert these in a future version. See telly github issue #108") - } - - lu := LineupItem{ - GuideNumber: strconv.Itoa(gn), - GuideName: finalName, - URL: fullTrackURI, - } - - lineup = append(lineup, lu) - - gn = gn + 1 - } - - return lineup -} + opts.lineup = NewLineup(opts) -func getM3U(opts config) (io.Reader, error) { - if strings.HasPrefix(strings.ToLower(opts.M3UPath), "http") { - log.Debugf("Downloading M3U from %s", opts.M3UPath) - resp, err := http.Get(opts.M3UPath) - if err != nil { - return nil, err + for _, playlistPath := range opts.Playlists { + if addErr := opts.lineup.AddPlaylist(playlistPath); addErr != nil { + log.WithError(addErr).Panicln("error adding new playlist to lineup") } - //defer resp.Body.Close() - - return resp.Body, nil } - log.Debugf("Reading M3U file %s...", opts.M3UPath) - - return os.Open(opts.M3UPath) -} + log.Infof("Loaded %d channels into the lineup", opts.lineup.FilteredTracksCount) -func filterTracks(tracks []*m3u.Track) ([]Track, error) { - allowedTracks := make([]Track, 0) - - for _, oldTrack := range tracks { - track := Track{Track: oldTrack} - if unmarshalErr := oldTrack.UnmarshalTags(&track); unmarshalErr != nil { - return nil, unmarshalErr - } - - if opts.Regex.MatchString(track.Name) == opts.RegexInclusive { - allowedTracks = append(allowedTracks, track) - } + if opts.lineup.FilteredTracksCount > 420 { + log.Warnln("telly has loaded more than 420 channels into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You have been warned!") } - return allowedTracks, nil + serve(opts) } diff --git a/routes.go b/routes.go index f1d1139..c48c89e 100644 --- a/routes.go +++ b/routes.go @@ -35,17 +35,31 @@ func serve(opts config) { router.GET("/", deviceXML(upnp)) router.GET("/discover.json", discovery(discoveryData)) router.GET("/lineup_status.json", lineupStatus(LineupStatus{ - ScanInProgress: 0, - ScanPossible: 1, + ScanInProgress: convertibleBoolean(opts.lineup.Refreshing), + ScanPossible: convertibleBoolean(true), Source: "Cable", SourceList: []string{"Cable"}, })) - router.GET("/lineup.post", func(c *gin.Context) { - c.AbortWithStatus(http.StatusNotImplemented) + router.POST("/lineup.post", func(c *gin.Context) { + scanAction := c.Query("scan") + if scanAction == "start" { + if refreshErr := opts.lineup.Refresh(); refreshErr != nil { + c.AbortWithError(http.StatusInternalServerError, refreshErr) + } + c.AbortWithStatus(http.StatusOK) + return + } else if scanAction == "abort" { + c.AbortWithStatus(http.StatusOK) + return + } + c.String(http.StatusBadRequest, "%s is not a valid scan command", scanAction) }) router.GET("/device.xml", deviceXML(upnp)) router.GET("/lineup.json", lineup(opts.lineup)) router.GET("/stream/:channelID", stream) + router.GET("/debug.json", func(c *gin.Context) { + c.JSON(http.StatusOK, opts.lineup) + }) if opts.SSDP { log.Debugln("advertising telly service on network via UPNP/SSDP") @@ -78,7 +92,7 @@ func lineupStatus(status LineupStatus) gin.HandlerFunc { } } -func lineup(lineup []LineupItem) gin.HandlerFunc { +func lineup(lineup *Lineup) gin.HandlerFunc { return func(c *gin.Context) { c.JSON(http.StatusOK, lineup) } diff --git a/structs.go b/structs.go index 6f1c25c..c2d6110 100644 --- a/structs.go +++ b/structs.go @@ -1,13 +1,12 @@ package main import ( + "encoding/json" "encoding/xml" "fmt" "net" "regexp" "strconv" - - "github.com/tombowditch/telly/m3u" ) type config struct { @@ -15,7 +14,7 @@ type config struct { Regex *regexp.Regexp DirectMode bool - M3UPath string + Playlists []string ConcurrentStreams int StartingChannel int @@ -35,7 +34,7 @@ type config struct { ListenAddress *net.TCPAddr BaseAddress *net.TCPAddr - lineup []LineupItem + lineup *Lineup } func (c *config) DiscoveryData() DiscoveryData { @@ -87,31 +86,12 @@ func (d *DiscoveryData) UPNP() UPNP { // LineupStatus exposes the status of the channel lineup. type LineupStatus struct { - ScanInProgress int - ScanPossible int + ScanInProgress convertibleBoolean + ScanPossible convertibleBoolean Source string SourceList []string } -// LineupItem is a single channel found in the playlist. -type LineupItem struct { - GuideNumber string - GuideName string - URL string -} - -// Track describes a single M3U segment. This struct includes m3u.Track as well as specific IPTV fields we want to get. -type Track struct { - *m3u.Track - Catchup string `m3u:"catchup"` - CatchupDays string `m3u:"catchup-days"` - CatchupSource string `m3u:"catchup-source"` - GroupTitle string `m3u:"group-title"` - TvgID string `m3u:"tvg-id"` - TvgLogo string `m3u:"tvg-logo"` - TvgName string `m3u:"tvg-name"` -} - type upnpVersion struct { Major int32 `xml:"major"` Minor int32 `xml:"minor"` @@ -134,3 +114,26 @@ type UPNP struct { URLBase string `xml:"URLBase"` Device upnpDevice `xml:"device"` } + +type convertibleBoolean bool + +func (bit *convertibleBoolean) MarshalJSON() ([]byte, error) { + var bitSetVar int8 + if *bit { + bitSetVar = 1 + } + + return json.Marshal(bitSetVar) +} + +func (bit *convertibleBoolean) UnmarshalJSON(data []byte) error { + asString := string(data) + if asString == "1" || asString == "true" { + *bit = true + } else if asString == "0" || asString == "false" { + *bit = false + } else { + return fmt.Errorf("Boolean unmarshal error: invalid input %s", asString) + } + return nil +} From acbdd527525b45099bc69462842ab5b1e9f3c807 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 12 Aug 2018 02:26:23 -0700 Subject: [PATCH 003/182] FIll PlaylistsCount --- lineup.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/lineup.go b/lineup.go index 9d6747a..46427e7 100644 --- a/lineup.go +++ b/lineup.go @@ -78,6 +78,7 @@ func (p *Playlist) Filter() error { Track: oldTrack, SafeURI: safeStringsRegex.ReplaceAllStringFunc(oldTrack.URI, stringSafer), } + if unmarshalErr := oldTrack.UnmarshalTags(&track); unmarshalErr != nil { return unmarshalErr } @@ -158,6 +159,7 @@ func (l *Lineup) AddPlaylist(path string) error { } l.Playlists = append(l.Playlists, *playlist) + l.PlaylistsCount = len(l.Playlists) l.TracksCount = l.TracksCount + playlist.TracksCount l.FilteredTracksCount = l.FilteredTracksCount + playlist.FilteredTracksCount From 4cdf2a9b058a22b4119439a9c44811f3b1a9ed9f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 12 Aug 2018 17:14:24 -0700 Subject: [PATCH 004/182] XMLTV/EPG parsing checkpoint --- lineup.go | 199 +++++++++++++-- main.go | 13 +- routes.go | 15 +- xmltv/xmltv.dtd | 575 ++++++++++++++++++++++++++++++++++++++++++++ xmltv/xmltv.go | 204 ++++++++++++++++ xmltv/xmltv_test.go | 135 +++++++++++ 6 files changed, 1119 insertions(+), 22 deletions(-) create mode 100644 xmltv/xmltv.dtd create mode 100644 xmltv/xmltv.go create mode 100644 xmltv/xmltv_test.go diff --git a/lineup.go b/lineup.go index 46427e7..7727eba 100644 --- a/lineup.go +++ b/lineup.go @@ -2,14 +2,19 @@ package main import ( "encoding/base64" + "encoding/xml" "fmt" "io" "net/http" "os" + "regexp" + "sort" + "strconv" "strings" "time" "github.com/tombowditch/telly/m3u" + "github.com/tombowditch/telly/xmltv" ) // Track describes a single M3U segment. This struct includes m3u.Track as well as specific IPTV fields we want to get. @@ -23,6 +28,9 @@ type Track struct { TvgID string `m3u:"tvg-id" json:",omitempty"` TvgLogo string `m3u:"tvg-logo" json:",omitempty"` TvgName string `m3u:"tvg-name" json:",omitempty"` + + XMLTVChannel xmlTVChannel `json:",omitempty"` + XMLTVProgrammes []xmltv.Programme `json:",omitempty"` } // Channel returns a Channel struct for the given Track. @@ -98,9 +106,8 @@ type M3UFile struct { Transport string } -// HDHomeRunChannel is a single channel found in the playlist. +// HDHomeRunChannel is a HDHomeRun specification compatible representation of a Track available in the Lineup. type HDHomeRunChannel struct { - // These fields match what HDHomeRun uses and Plex expects to see. AudioCodec string `json:",omitempty"` DRM convertibleBoolean `json:",string,omitempty"` Favorite convertibleBoolean `json:",string,omitempty"` @@ -126,21 +133,40 @@ type Lineup struct { Refreshing bool LastRefreshed time.Time `json:",omitempty"` + + xmlTvChannelMap map[string]xmlTVChannel + channelsInXMLTv []string + xmlTv xmltv.TV + xmlTvSourceInfoURL []string + xmlTvSourceInfoName []string + xmlTvSourceDataURL []string } // NewLineup returns a new Lineup for the given config struct. func NewLineup(opts config) *Lineup { - return &Lineup{ + tv := xmltv.TV{ + GeneratorInfoName: namespaceWithVersion, + GeneratorInfoURL: "https://github.com/tombowditch/telly", + } + + lineup := &Lineup{ + xmlTv: tv, + xmlTvChannelMap: make(map[string]xmlTVChannel), StartingChannelNumber: opts.StartingChannel, channelNumber: opts.StartingChannel, ObfuscateURL: !opts.DirectMode, Refreshing: true, LastRefreshed: time.Now(), } + + return lineup } // AddPlaylist adds a new playlist to the Lineup. -func (l *Lineup) AddPlaylist(path string) error { +func (l *Lineup) AddPlaylist(plist string) error { + // Attempt to split the string by semi colon for complex config passing with m3uPath,xmlPath,name + splitStr := strings.Split(plist, ";") + path := splitStr[0] reader, info, readErr := l.getM3U(path) if readErr != nil { log.WithError(readErr).Errorln("error getting m3u") @@ -153,6 +179,23 @@ func (l *Lineup) AddPlaylist(path string) error { return err } + if len(splitStr) > 1 { + epg, epgReadErr := l.getXMLTV(splitStr[1]) + if epgReadErr != nil { + log.WithError(epgReadErr).Errorln("error getting XMLTV") + return epgReadErr + } + + chanMap, chanMapErr := l.processXMLTV(epg) + if chanMapErr != nil { + log.WithError(chanMapErr).Errorln("Error building channel mapping") + } + + for chanID, chann := range chanMap { + l.xmlTvChannelMap[chanID] = chann + } + } + playlist, playlistErr := l.NewPlaylist(rawPlaylist, info) if playlistErr != nil { return playlistErr @@ -175,13 +218,30 @@ func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile) (*Playlis return nil, filterErr } - for _, track := range playlist.Tracks { + for idx, track := range playlist.Tracks { + + channelNumber := l.channelNumber + + if xmlChan, ok := l.xmlTvChannelMap[track.TvgID]; ok && !contains(l.channelsInXMLTv, track.TvgID) { + log.Infoln("found an entry in xmlTvChannelMap for", track.TvgID) + channelNumber = xmlChan.Number + l.channelsInXMLTv = append(l.channelsInXMLTv, track.TvgID) + track.XMLTVChannel = xmlChan + l.xmlTv.Channels = append(l.xmlTv.Channels, xmlChan.Original) + if xmlChan.Programmes != nil { + track.XMLTVProgrammes = xmlChan.Programmes + l.xmlTv.Programmes = append(l.xmlTv.Programmes, xmlChan.Programmes...) + } + playlist.Tracks[idx] = track + } - channel := track.Channel(l.channelNumber, l.ObfuscateURL) + channel := track.Channel(channelNumber, l.ObfuscateURL) playlist.Channels = append(playlist.Channels, *channel) - l.channelNumber = l.channelNumber + 1 + if channelNumber == l.channelNumber { // Only increment lineup channel number if its for a channel that didnt have a XMLTV entry. + l.channelNumber = l.channelNumber + 1 + } } playlist.FilteredTracksCount = len(playlist.Tracks) @@ -222,28 +282,137 @@ func (l *Lineup) getM3U(path string) (io.Reader, *M3UFile, error) { safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) log.Infof("Loading M3U from %s", safePath) - info := &M3UFile{ + file, transport, err := l.getFile(path) + if err != nil { + return nil, nil, err + } + + return file, &M3UFile{ Path: path, SafePath: safePath, - Transport: "disk", + Transport: transport, + }, nil +} + +func (l *Lineup) getXMLTV(path string) (*xmltv.TV, error) { + file, _, err := l.getFile(path) + if err != nil { + return nil, err } + decoder := xml.NewDecoder(file) + tvSetup := new(xmltv.TV) + if err := decoder.Decode(tvSetup); err != nil { + log.WithError(err).Errorln("Could not decode xmltv programme") + return nil, err + } + + return tvSetup, nil +} + +func (l *Lineup) getFile(path string) (io.Reader, string, error) { + safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + log.Infof("Loading file from %s", safePath) + + transport := "disk" + if strings.HasPrefix(strings.ToLower(path), "http") { resp, err := http.Get(path) if err != nil { - return nil, nil, err + return nil, transport, err } //defer resp.Body.Close() - info.Transport = "http" - - return resp.Body, info, nil + return resp.Body, transport, nil } file, fileErr := os.Open(path) if fileErr != nil { - return nil, nil, fileErr + return nil, transport, fileErr + } + + return file, transport, nil +} + +var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString +var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString + +type xmlTVChannel struct { + ID string + Number int + CallSign string + ShortName string + LongName string + + NumberAssigned bool + + Programmes []xmltv.Programme + + Original xmltv.Channel +} + +func (l *Lineup) processXMLTV(tv *xmltv.TV) (map[string]xmlTVChannel, error) { + programmeMap := make(map[string][]xmltv.Programme) + for _, programme := range tv.Programmes { + programmeMap[programme.Channel] = append(programmeMap[programme.Channel], programme) + } + + channelMap := make(map[string]xmlTVChannel, 0) + startManualNumber := 10000 + for _, tvChann := range tv.Channels { + xTVChan := xmlTVChannel{ + ID: tvChann.ID, + Original: tvChann, + } + if programmes, ok := programmeMap[tvChann.ID]; ok { + xTVChan.Programmes = programmes + } + displayNames := []string{} + for _, displayName := range tvChann.DisplayNames { + displayNames = append(displayNames, displayName.Value) + } + sort.StringSlice(displayNames).Sort() + for i := 0; i < 10; i++ { + iterateDisplayNames(displayNames, &xTVChan) + } + if xTVChan.Number == 0 { + xTVChan.Number = startManualNumber + 1 + startManualNumber = xTVChan.Number + xTVChan.NumberAssigned = true + } + channelMap[xTVChan.ID] = xTVChan } + return channelMap, nil +} - return file, info, nil +func iterateDisplayNames(displayNames []string, xTVChan *xmlTVChannel) { + for _, displayName := range displayNames { + if channelNumberRegex(displayName) { + if chanNum, chanNumErr := strconv.Atoi(displayName); chanNumErr == nil { + log.Debugln(displayName, "is channel number!") + xTVChan.Number = chanNum + } + } else if !strings.HasPrefix(displayName, fmt.Sprintf("%d", xTVChan.Number)) { + if xTVChan.LongName == "" { + xTVChan.LongName = displayName + log.Debugln(displayName, "is long name!") + } else if !callSignRegex(displayName) && len(xTVChan.LongName) < len(displayName) { + xTVChan.ShortName = xTVChan.LongName + xTVChan.LongName = displayName + log.Debugln(displayName, "is NEW long name, replacing", xTVChan.ShortName) + } else if callSignRegex(displayName) { + xTVChan.CallSign = displayName + log.Debugln(displayName, "is call sign!") + } + } + } +} + +func contains(s []string, e string) bool { + for _, a := range s { + if a == e { + return true + } + } + return false } diff --git a/main.go b/main.go index 8b0ba1a..7ae1f7d 100644 --- a/main.go +++ b/main.go @@ -12,9 +12,10 @@ import ( ) var ( - namespace = "telly" - log = logrus.New() - opts = config{} + namespace = "telly" + namespaceWithVersion = fmt.Sprintf("%s %s", namespace, version.Version) + log = logrus.New() + opts = config{} exposedChannels = prometheus.NewGauge( prometheus.GaugeOpts{ @@ -111,9 +112,9 @@ func main() { log.Infof("Loaded %d channels into the lineup", opts.lineup.FilteredTracksCount) - if opts.lineup.FilteredTracksCount > 420 { - log.Warnln("telly has loaded more than 420 channels into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You have been warned!") - } + // if opts.lineup.FilteredTracksCount > 420 { + // log.Panicln("telly has loaded more than 420 channels into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You must use regular expressions to filter out channels. You can also start another Telly instance.") + // } serve(opts) } diff --git a/routes.go b/routes.go index c48c89e..b952698 100644 --- a/routes.go +++ b/routes.go @@ -4,6 +4,7 @@ import ( "encoding/base64" "fmt" "net/http" + "sort" "time" "github.com/gin-gonic/gin" @@ -57,6 +58,7 @@ func serve(opts config) { router.GET("/device.xml", deviceXML(upnp)) router.GET("/lineup.json", lineup(opts.lineup)) router.GET("/stream/:channelID", stream) + router.GET("/epg.xml", xmlTV(opts.lineup)) router.GET("/debug.json", func(c *gin.Context) { c.JSON(http.StatusOK, opts.lineup) }) @@ -94,7 +96,18 @@ func lineupStatus(status LineupStatus) gin.HandlerFunc { func lineup(lineup *Lineup) gin.HandlerFunc { return func(c *gin.Context) { - c.JSON(http.StatusOK, lineup) + allChannels := make([]HDHomeRunChannel, 0) + for _, playlist := range lineup.Playlists { + allChannels = append(allChannels, playlist.Channels...) + } + sort.Slice(allChannels, func(i, j int) bool { return allChannels[i].GuideNumber < allChannels[j].GuideNumber }) + c.JSON(http.StatusOK, allChannels) + } +} + +func xmlTV(lineup *Lineup) gin.HandlerFunc { + return func(c *gin.Context) { + c.XML(http.StatusOK, lineup.xmlTv) } } diff --git a/xmltv/xmltv.dtd b/xmltv/xmltv.dtd new file mode 100644 index 0000000..3c4812e --- /dev/null +++ b/xmltv/xmltv.dtd @@ -0,0 +1,575 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/xmltv/xmltv.go b/xmltv/xmltv.go new file mode 100644 index 0000000..6795f43 --- /dev/null +++ b/xmltv/xmltv.go @@ -0,0 +1,204 @@ +// Package xmltv provides structures for parsing XMLTV data. +package xmltv + +import ( + "encoding/xml" + "os" + "time" + + "golang.org/x/net/html/charset" +) + +// Time that holds the time which is parsed from XML +type Time struct { + time.Time +} + +// MarshalXMLAttr is used to marshal a Go time.Time into the XMLTV Format. +func (t *Time) MarshalXMLAttr(name xml.Name) (xml.Attr, error) { + return xml.Attr{ + Name: name, + Value: t.Format("20060102150405 -0700"), + }, nil +} + +// UnmarshalXMLAttr is used to unmarshal a time in the XMLTV format to a time.Time. +func (t *Time) UnmarshalXMLAttr(attr xml.Attr) error { + t1, err := time.Parse("20060102150405 -0700", attr.Value) + if err != nil { + return err + } + + *t = Time{t1} + return nil +} + +// TV is the root element. +type TV struct { + Channels []Channel `xml:"channel" json:"channels"` + Programmes []Programme `xml:"programme" json:"programmes"` + Date string `xml:"date,attr,omitempty" json:"date,omitempty"` + SourceInfoURL string `xml:"source-info-url,attr,omitempty" json:"source_info_url,omitempty"` + SourceInfoName string `xml:"source-info-name,attr,omitempty" json:"source_info_name,omitempty"` + SourceDataURL string `xml:"source-data-url,attr,omitempty" json:"source_data_url,omitempty"` + GeneratorInfoName string `xml:"generator-info-name,attr,omitempty" json:"generator_info_name,omitempty"` + GeneratorInfoURL string `xml:"generator-info-url,attr,omitempty" json:"generator_info_url,omitempty"` +} + +// LoadXML loads the XMLTV XML from file. +func (t *TV) LoadXML(f *os.File) error { + decoder := xml.NewDecoder(f) + decoder.CharsetReader = charset.NewReaderLabel + + err := decoder.Decode(&t) + if err != nil { + return err + } + + return nil +} + +// Channel details of a channel +type Channel struct { + DisplayNames []CommonElement `xml:"display-name" json:"display_names" ` + Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` + URLs []string `xml:"url,omitempty" json:"urls,omitempty" ` + ID string `xml:"id,attr" json:"id,omitempty" ` +} + +// Programme details of a single programme transmission +type Programme struct { + ID string `xml:"id,attr,omitempty" json:"id,omitempty"` // not defined by standard, but often present + Titles []CommonElement `xml:"title" json:"titles"` + SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondary_titles,omitempty"` + Descriptions []CommonElement `xml:"desc,omitempty" json:"descriptions,omitempty"` + Credits *Credits `xml:"credits,omitempty" json:"credits,omitempty"` + Date string `xml:"date,omitempty" json:"date,omitempty"` + Categories []CommonElement `xml:"category,omitempty" json:"categories,omitempty"` + Keywords []CommonElement `xml:"keyword,omitempty" json:"keywords,omitempty"` + Languages []CommonElement `xml:"language,omitempty" json:"languages,omitempty"` + OrigLanguages []CommonElement `xml:"orig-language,omitempty" json:"orig_languages,omitempty"` + Length *Length `xml:"length,omitempty" json:"length,omitempty"` + Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` + URLs []string `xml:"url,omitempty" json:"urls,omitempty"` + Countries []CommonElement `xml:"country,omitempty" json:"countries,omitempty"` + EpisodeNums []EpisodeNum `xml:"episode-num,omitempty" json:"episode_nums,omitempty"` + Video *Video `xml:"video,omitempty" json:"video,omitempty"` + Audio *Audio `xml:"audio,omitempty" json:"audio,omitempty"` + PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` + Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` + LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` + New ElementPresent `xml:"new" json:"new"` + Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` + Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` + StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` + Reviews []Review `xml:"review,omitempty" json:"reviews,omitempty"` + Start *Time `xml:"start,attr" json:"start"` + Stop *Time `xml:"stop,attr,omitempty" json:"stop,omitempty"` + PDCStart *Time `xml:"pdc-start,attr,omitempty" json:"pdc_start,omitempty"` + VPSStart *Time `xml:"vps-start,attr,omitempty" json:"vps_start,omitempty"` + Showview string `xml:"showview,attr,omitempty" json:"showview,omitempty"` + Videoplus string `xml:"videoplus,attr,omitempty" json:"videoplus,omitempty"` + Channel string `xml:"channel,attr" json:"channel"` + Clumpidx string `xml:"clumpidx,attr,omitempty" json:"clumpidx,omitempty"` +} + +// CommonElement element structure that is common, i.e. Italy +type CommonElement struct { + Lang string `xml:"lang,attr,omitempty" json:"lang,omitempty" ` + Value string `xml:",chardata" json:"value,omitempty"` +} + +// ElementPresent used to determine if element is present or not +type ElementPresent bool + +// UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 +func (c *ElementPresent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + var v string + if decodeErr := d.DecodeElement(&v, &start); decodeErr != nil { + return decodeErr + } + *c = true + return nil +} + +// Icon associated with the element that contains it +type Icon struct { + Source string `xml:"src,attr" json:"source"` + Width int `xml:"width,attr" json:"width"` + Height int `xml:"height,attr" json:"height"` +} + +// Credits for the programme +type Credits struct { + Directors []string `xml:"director,omitempty" json:"directors,omitempty"` + Actors []Actor `xml:"actor,omitempty" json:"actors,omitempty"` + Writers []string `xml:"writer,omitempty" json:"writers,omitempty"` + Adapters []string `xml:"adapter,omitempty" json:"adapters,omitempty"` + Producers []string `xml:"producer,omitempty" json:"producers,omitempty"` + Composers []string `xml:"composer,omitempty" json:"composers,omitempty"` + Editors []string `xml:"editor,omitempty" json:"editors,omitempty"` + Presenters []string `xml:"presenter,omitempty" json:"presenters,omitempty"` + Commentators []string `xml:"commentator,omitempty" json:"commentators,omitempty"` + Guests []string `xml:"guest,omitempty" json:"guests,omitempty"` +} + +// Actor in a programme +type Actor struct { + Role string `xml:"role,attr,omitempty" json:"role,omitempty"` + Value string `xml:",chardata" json:"value"` +} + +// Length of the programme +type Length struct { + Units string `xml:"units,attr" json:"units"` + Value string `xml:",chardata" json:"value"` +} + +// EpisodeNum of the programme +type EpisodeNum struct { + System string `xml:"system,attr,omitempty" json:"system,omitempty"` + Value string `xml:",chardata" json:"value"` +} + +// Video details of the programme +type Video struct { + Present string `xml:"present,omitempty" json:"present,omitempty"` + Colour string `xml:"colour,omitempty" json:"colour,omitempty"` + Aspect string `xml:"aspect,omitempty" json:"aspect,omitempty"` + Quality string `xml:"quality,omitempty" json:"quality,omitempty"` +} + +// Audio details of the programme +type Audio struct { + Present string `xml:"present,omitempty" json:"present,omitempty"` + Stereo string `xml:"stereo,omitempty" json:"stereo,omitempty"` +} + +// PreviouslyShown When and where the programme was last shown, if known. +type PreviouslyShown struct { + Start string `xml:"start,attr,omitempty" json:"start,omitempty"` + Channel string `xml:"channel,attr,omitempty" json:"channel,omitempty"` +} + +// Subtitle in a programme +type Subtitle struct { + Language *CommonElement `xml:"language,omitempty" json:"language,omitempty"` + Type string `xml:"type,attr,omitempty" json:"type,omitempty"` +} + +// Rating of a programme +type Rating struct { + Value string `xml:"value" json:"value"` + Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` + System string `xml:"system,attr,omitempty" json:"system,omitempty"` +} + +// Review of a programme +type Review struct { + Value string `xml:",chardata" json:"value"` + Type string `xml:"type" json:"type"` + Source string `xml:"source,omitempty" json:"source,omitempty"` + Reviewer string `xml:"reviewer,omitempty" json:"reviewer,omitempty"` + Lang string `xml:"lang,omitempty" json:"lang,omitempty"` +} diff --git a/xmltv/xmltv_test.go b/xmltv/xmltv_test.go new file mode 100644 index 0000000..0cdc479 --- /dev/null +++ b/xmltv/xmltv_test.go @@ -0,0 +1,135 @@ +package xmltv + +import ( + "encoding/xml" + "fmt" + "io" + "os" + "reflect" + "testing" + "time" + + "github.com/kr/pretty" +) + +func dummyReader(charset string, input io.Reader) (io.Reader, error) { + return input, nil +} + +func TestDecode(t *testing.T) { + // Example downloaded from http://wiki.xmltv.org/index.php/XMLTVFormat + // One may check it with `xmllint --noout --dtdvalid xmltv.dtd example.xml` + f, err := os.Open("example.xml") + if err != nil { + t.Fatal(err) + } + defer f.Close() + + var tv TV + dec := xml.NewDecoder(f) + dec.CharsetReader = dummyReader + err = dec.Decode(&tv) + if err != nil { + t.Fatal(err) + } + + ch := Channel{ + ID: "I10436.labs.zap2it.com", + DisplayNames: []CommonElement{ + CommonElement{ + Value: "13 KERA", + }, + CommonElement{ + Value: "13 KERA TX42822:-", + }, + CommonElement{ + Value: "13", + }, + CommonElement{ + Value: "13 KERA fcc", + }, + CommonElement{ + Value: "KERA", + }, + CommonElement{ + Value: "KERA", + }, + CommonElement{ + Value: "PBS Affiliate", + }, + }, + Icons: []Icon{ + Icon{ + Source: `file://C:\Perl\site/share/xmltv/icons/KERA.gif`, + }, + }, + } + if !reflect.DeepEqual(ch, tv.Channels[0]) { + t.Errorf("\texpected: %# v\n\t\tactual: %# v\n", pretty.Formatter(ch), pretty.Formatter(tv.Channels[0])) + } + + loc := time.FixedZone("", -6*60*60) + pr := Programme{ + ID: "someId", + Date: "20080711", + Channel: "I10436.labs.zap2it.com", + Start: &Time{time.Date(2008, 07, 15, 0, 30, 0, 0, loc)}, + Stop: &Time{time.Date(2008, 07, 15, 1, 0, 0, 0, loc)}, + Titles: []CommonElement{ + CommonElement{ + Lang: "en", + Value: "NOW on PBS", + }, + }, + Descriptions: []CommonElement{ + CommonElement{ + Lang: "en", + Value: "Jordan's Queen Rania has made job creation a priority to help curb the staggering unemployment rates among youths in the Middle East.", + }, + }, + Categories: []CommonElement{ + CommonElement{ + Lang: "en", + Value: "Newsmagazine", + }, + CommonElement{ + Lang: "en", + Value: "Interview", + }, + CommonElement{ + Lang: "en", + Value: "Public affairs", + }, + CommonElement{ + Lang: "en", + Value: "Series", + }, + }, + EpisodeNums: []EpisodeNum{ + EpisodeNum{ + System: "dd_progid", + Value: "EP01006886.0028", + }, + EpisodeNum{ + System: "onscreen", + Value: "427", + }, + }, + Audio: &Audio{ + Stereo: "stereo", + }, + PreviouslyShown: &PreviouslyShown{ + Start: "20080711000000", + }, + Subtitles: []Subtitle{ + Subtitle{ + Type: "teletext", + }, + }, + } + if !reflect.DeepEqual(pr, tv.Programmes[0]) { + expected := fmt.Sprintf("\texpected: %# v\n\t\t\texpected start: %s\n\t\t\texpected stop : %s", pretty.Formatter(pr), pr.Start, pr.Stop) + actual := fmt.Sprintf("\tactual: %# v\n\t\t\tactual start: %s\n\t\t\tactual stop: %s", pretty.Formatter(tv.Programmes[0]), tv.Programmes[0].Start, tv.Programmes[0].Stop) + t.Errorf("%s\n%s\n", expected, actual) + } +} From d7f66faf4ff39ab05c78ba227630abe2d75c1aba Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 13 Aug 2018 19:55:01 -0700 Subject: [PATCH 005/182] XMLTV checkpoint --- Gopkg.lock | 49 ++++++++++- VERSION | 2 +- lineup.go | 217 +++++++++++++++++++++++++++++++------------------ main.go | 18 ++-- routes.go | 53 +++++++----- structs.go | 16 ++-- xmltv/xmltv.go | 18 +++- 7 files changed, 252 insertions(+), 121 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index 6544274..cc87f39 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -64,6 +64,22 @@ pruneopts = "UT" revision = "4a0ed625a78b6858dc8d3a55fb7728968b712122" +[[projects]] + digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394" + name = "github.com/kr/pretty" + packages = ["."] + pruneopts = "UT" + revision = "73f6ac0b30a98e433b289500d779f50c1a6f0712" + version = "v0.1.0" + +[[projects]] + digest = "1:15b5cc79aad436d47019f814fde81a10221c740dc8ddf769221a65097fb6c2e9" + name = "github.com/kr/text" + packages = ["."] + pruneopts = "UT" + revision = "e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f" + version = "v0.1.0" + [[projects]] digest = "1:fa610f9fe6a93f4a75e64c83673dfff9bf1a34bbb21e6102021b6bc7850834a3" name = "github.com/mattn/go-isatty" @@ -165,10 +181,13 @@ [[projects]] branch = "master" - digest = "1:937d8f64b118c494c48b0cc9c990f2163c7483e6c70b5828f20006d81c61412f" + digest = "1:2d073118530c09a068ae1c47b054b5bdf75f625621658ecb642bcad7e65eb66a" name = "golang.org/x/net" packages = [ "bpf", + "html", + "html/atom", + "html/charset", "internal/iana", "internal/socket", "ipv4", @@ -187,6 +206,32 @@ pruneopts = "UT" revision = "98c5dad5d1a0e8a73845ecc8897d0bd56586511d" +[[projects]] + digest = "1:aa4d6967a3237f8367b6bf91503964a77183ecf696f1273e8ad3551bb4412b5f" + name = "golang.org/x/text" + packages = [ + "encoding", + "encoding/charmap", + "encoding/htmlindex", + "encoding/internal", + "encoding/internal/identifier", + "encoding/japanese", + "encoding/korean", + "encoding/simplifiedchinese", + "encoding/traditionalchinese", + "encoding/unicode", + "internal/gen", + "internal/tag", + "internal/utf8internal", + "language", + "runes", + "transform", + "unicode/cldr", + ] + pruneopts = "UT" + revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" + version = "v0.3.0" + [[projects]] digest = "1:c06d9e11d955af78ac3bbb26bd02e01d2f61f689e1a3bce2ef6fb683ef8a7f2d" name = "gopkg.in/alecthomas/kingpin.v2" @@ -216,11 +261,13 @@ input-imports = [ "github.com/gin-gonic/gin", "github.com/koron/go-ssdp", + "github.com/kr/pretty", "github.com/mitchellh/mapstructure", "github.com/prometheus/client_golang/prometheus", "github.com/prometheus/common/version", "github.com/sirupsen/logrus", "github.com/zsais/go-gin-prometheus", + "golang.org/x/net/html/charset", "gopkg.in/alecthomas/kingpin.v2", ] solver-name = "gps-cdcl" diff --git a/VERSION b/VERSION index 21e8796..9084fa2 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.0.3 +1.1.0 diff --git a/lineup.go b/lineup.go index 7727eba..bbfbb87 100644 --- a/lineup.go +++ b/lineup.go @@ -1,7 +1,6 @@ package main import ( - "encoding/base64" "encoding/xml" "fmt" "io" @@ -17,55 +16,38 @@ import ( "github.com/tombowditch/telly/xmltv" ) +var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString +var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString +var hdRegex = regexp.MustCompile(`hd|4k`) + // Track describes a single M3U segment. This struct includes m3u.Track as well as specific IPTV fields we want to get. type Track struct { *m3u.Track - SafeURI string `json:"URI"` - Catchup string `m3u:"catchup" json:",omitempty"` - CatchupDays string `m3u:"catchup-days" json:",omitempty"` - CatchupSource string `m3u:"catchup-source" json:",omitempty"` - GroupTitle string `m3u:"group-title" json:",omitempty"` - TvgID string `m3u:"tvg-id" json:",omitempty"` - TvgLogo string `m3u:"tvg-logo" json:",omitempty"` - TvgName string `m3u:"tvg-name" json:",omitempty"` - - XMLTVChannel xmlTVChannel `json:",omitempty"` - XMLTVProgrammes []xmltv.Programme `json:",omitempty"` + SafeURI string `json:"URI"` + Catchup string `m3u:"catchup" json:",omitempty"` + CatchupDays string `m3u:"catchup-days" json:",omitempty"` + CatchupSource string `m3u:"catchup-source" json:",omitempty"` + GroupTitle string `m3u:"group-title" json:",omitempty"` + TvgID string `m3u:"tvg-id" json:",omitempty"` + TvgLogo string `m3u:"tvg-logo" json:",omitempty"` + TvgName string `m3u:"tvg-name" json:",omitempty"` + TvgChannelNumber string `m3u:"tvg-chno" json:",omitempty"` + ChannelID string `m3u:"channel-id" json:",omitempty"` + + XMLTVChannel *xmlTVChannel `json:",omitempty"` + XMLTVProgrammes *[]xmltv.Programme `json:",omitempty"` } -// Channel returns a Channel struct for the given Track. -func (t *Track) Channel(number int, obfuscate bool) *HDHomeRunChannel { - var finalName string - if t.TvgName == "" { - finalName = t.Name - } else { - finalName = t.TvgName +func (t *Track) PrettyName() string { + if t.XMLTVChannel != nil { + return t.XMLTVChannel.LongName + } else if t.TvgName != "" { + return t.TvgName + } else if t.Track.Name != "" { + return t.Track.Name } - // base64 url - fullTrackURI := t.URI - if obfuscate { - trackURI := base64.StdEncoding.EncodeToString([]byte(t.URI)) - fullTrackURI = fmt.Sprintf("http://%s/stream/%s", opts.BaseAddress.String(), trackURI) - } - - // if strings.Contains(t.URI, ".m3u8") { - // log.Warnln("your .m3u contains .m3u8's. Plex has either stopped supporting m3u8 or it is a bug in a recent version - please use .ts! telly will automatically convert these in a future version. See telly github issue #108") - // } - - hd := false - if strings.Contains(strings.ToLower(t.Track.Raw), "hd") { - hd = true - } - - return &HDHomeRunChannel{ - GuideNumber: number, - GuideName: finalName, - URL: fullTrackURI, - HD: convertibleBoolean(hd), - - track: t, - } + return t.Name } // Playlist describes a single M3U playlist. @@ -77,6 +59,7 @@ type Playlist struct { Channels []HDHomeRunChannel TracksCount int FilteredTracksCount int + EPGProvided bool } // Filter will filter the raw m3u.Playlist m3u.Track slice into the Track slice of the Playlist. @@ -91,7 +74,7 @@ func (p *Playlist) Filter() error { return unmarshalErr } - if opts.Regex.MatchString(track.Name) == opts.RegexInclusive { + if opts.Regex.MatchString(track.Raw) == opts.RegexInclusive { p.Tracks = append(p.Tracks, track) } } @@ -129,7 +112,6 @@ type Lineup struct { StartingChannelNumber int channelNumber int - ObfuscateURL bool Refreshing bool LastRefreshed time.Time `json:",omitempty"` @@ -140,6 +122,9 @@ type Lineup struct { xmlTvSourceInfoURL []string xmlTvSourceInfoName []string xmlTvSourceDataURL []string + xmlTVChannelNumbers bool + + chanNumToURLMap map[string]string } // NewLineup returns a new Lineup for the given config struct. @@ -150,12 +135,13 @@ func NewLineup(opts config) *Lineup { } lineup := &Lineup{ + xmlTVChannelNumbers: opts.XMLTVChannelNumbers, + chanNumToURLMap: make(map[string]string), xmlTv: tv, xmlTvChannelMap: make(map[string]xmlTVChannel), StartingChannelNumber: opts.StartingChannel, channelNumber: opts.StartingChannel, - ObfuscateURL: !opts.DirectMode, - Refreshing: true, + Refreshing: false, LastRefreshed: time.Now(), } @@ -196,12 +182,12 @@ func (l *Lineup) AddPlaylist(plist string) error { } } - playlist, playlistErr := l.NewPlaylist(rawPlaylist, info) + playlist, playlistErr := l.NewPlaylist(rawPlaylist, info, (len(splitStr) > 1)) if playlistErr != nil { return playlistErr } - l.Playlists = append(l.Playlists, *playlist) + l.Playlists = append(l.Playlists, playlist) l.PlaylistsCount = len(l.Playlists) l.TracksCount = l.TracksCount + playlist.TracksCount l.FilteredTracksCount = l.FilteredTracksCount + playlist.FilteredTracksCount @@ -210,40 +196,56 @@ func (l *Lineup) AddPlaylist(plist string) error { } // NewPlaylist will return a new and filtered Playlist for the given m3u.Playlist and M3UFile. -func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile) (*Playlist, error) { - playlist := &Playlist{rawPlaylist, info, nil, nil, len(rawPlaylist.Tracks), 0} +func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile, hasEPG bool) (Playlist, error) { + playlist := Playlist{rawPlaylist, info, nil, nil, len(rawPlaylist.Tracks), 0, hasEPG} if filterErr := playlist.Filter(); filterErr != nil { log.WithError(filterErr).Errorln("error during filtering of channels, check your regex and try again") - return nil, filterErr + return playlist, filterErr } for idx, track := range playlist.Tracks { + tt, channelNumber, hd, ttErr := l.processTrack(hasEPG, track) + if ttErr != nil { + return playlist, ttErr + } - channelNumber := l.channelNumber - - if xmlChan, ok := l.xmlTvChannelMap[track.TvgID]; ok && !contains(l.channelsInXMLTv, track.TvgID) { - log.Infoln("found an entry in xmlTvChannelMap for", track.TvgID) - channelNumber = xmlChan.Number - l.channelsInXMLTv = append(l.channelsInXMLTv, track.TvgID) - track.XMLTVChannel = xmlChan - l.xmlTv.Channels = append(l.xmlTv.Channels, xmlChan.Original) - if xmlChan.Programmes != nil { - track.XMLTVProgrammes = xmlChan.Programmes - l.xmlTv.Programmes = append(l.xmlTv.Programmes, xmlChan.Programmes...) - } - playlist.Tracks[idx] = track + if hasEPG && tt.XMLTVChannel == nil { + log.Warnf("%s (#%d) is not being exposed to Plex because there was no EPG data found.", tt.Name, channelNumber) + continue } - channel := track.Channel(channelNumber, l.ObfuscateURL) + playlist.Tracks[idx] = *tt + + guideName := tt.PrettyName() - playlist.Channels = append(playlist.Channels, *channel) + log.Debugln("Assigning", channelNumber, l.channelNumber, "to", guideName) + + hdhr := HDHomeRunChannel{ + GuideNumber: channelNumber, + GuideName: guideName, + URL: fmt.Sprintf("http://%s/auto/v%d", opts.BaseAddress.String(), channelNumber), + HD: convertibleBoolean(hd), + DRM: convertibleBoolean(false), + } + + if !channelExists(playlist.Channels, hdhr) { + playlist.Channels = append(playlist.Channels, hdhr) + l.chanNumToURLMap[strconv.Itoa(channelNumber)] = tt.Track.URI + } if channelNumber == l.channelNumber { // Only increment lineup channel number if its for a channel that didnt have a XMLTV entry. l.channelNumber = l.channelNumber + 1 } + } + sort.Slice(l.xmlTv.Channels, func(i, j int) bool { + first, _ := strconv.Atoi(l.xmlTv.Channels[i].ID) + second, _ := strconv.Atoi(l.xmlTv.Channels[j].ID) + return first < second + }) + playlist.FilteredTracksCount = len(playlist.Tracks) exposedChannels.Add(float64(playlist.FilteredTracksCount)) log.Debugf("Added %d channels to the lineup", playlist.FilteredTracksCount) @@ -251,8 +253,48 @@ func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile) (*Playlis return playlist, nil } +func (l Lineup) processTrack(hasEPG bool, track Track) (*Track, int, bool, error) { + hd := hdRegex.MatchString(strings.ToLower(track.Track.Raw)) + channelNumber := l.channelNumber + if xmlChan, ok := l.xmlTvChannelMap[track.TvgID]; ok { + log.Debugln("found an entry in xmlTvChannelMap for", track.Name) + if l.xmlTVChannelNumbers && xmlChan.Number != 0 { + channelNumber = xmlChan.Number + } else { + xmlChan.Number = channelNumber + } + l.channelsInXMLTv = append(l.channelsInXMLTv, track.TvgID) + track.XMLTVChannel = &xmlChan + l.xmlTv.Channels = append(l.xmlTv.Channels, xmlChan.RemappedChannel(track)) + if xmlChan.Programmes != nil { + track.XMLTVProgrammes = &xmlChan.Programmes + for _, programme := range xmlChan.Programmes { + newProgramme := programme + for idx, title := range programme.Titles { + programme.Titles[idx].Value = strings.Replace(title.Value, " [New!]", "", -1) // Hardcoded fix for Vaders + } + newProgramme.Channel = strconv.Itoa(channelNumber) + if hd { + if newProgramme.Video == nil { + newProgramme.Video = &xmltv.Video{} + } + newProgramme.Video.Quality = "HDTV" + } + l.xmlTv.Programmes = append(l.xmlTv.Programmes, newProgramme) + } + } + } + + return &track, channelNumber, hd, nil +} + // Refresh will rescan all playlists for any channel changes. -func (l *Lineup) Refresh() error { +func (l Lineup) Refresh() error { + + if l.Refreshing { + log.Warnln("A refresh is already underway yet, another one was requested") + return nil + } log.Warnln("Refreshing the lineup!") @@ -272,6 +314,8 @@ func (l *Lineup) Refresh() error { } } + log.Infoln("Done refreshing the lineup!") + l.LastRefreshed = time.Now() l.Refreshing = false @@ -334,9 +378,6 @@ func (l *Lineup) getFile(path string) (io.Reader, string, error) { return file, transport, nil } -var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString -var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString - type xmlTVChannel struct { ID string Number int @@ -351,6 +392,18 @@ type xmlTVChannel struct { Original xmltv.Channel } +func (x *xmlTVChannel) RemappedChannel(t Track) xmltv.Channel { + newX := x.Original + newX.ID = strconv.Itoa(x.Number) + if t.TvgLogo != "" { + newX.Icons = append(newX.Icons, xmltv.Icon{Source: t.TvgLogo}) + } + if t.Track.Name != "" { + newX.DisplayNames = append(newX.DisplayNames, xmltv.CommonElement{Value: t.Track.Name}) + } + return newX +} + func (l *Lineup) processXMLTV(tv *xmltv.TV) (map[string]xmlTVChannel, error) { programmeMap := make(map[string][]xmltv.Programme) for _, programme := range tv.Programmes { @@ -358,30 +411,32 @@ func (l *Lineup) processXMLTV(tv *xmltv.TV) (map[string]xmlTVChannel, error) { } channelMap := make(map[string]xmlTVChannel, 0) - startManualNumber := 10000 for _, tvChann := range tv.Channels { - xTVChan := xmlTVChannel{ + xTVChan := &xmlTVChannel{ ID: tvChann.ID, Original: tvChann, } if programmes, ok := programmeMap[tvChann.ID]; ok { xTVChan.Programmes = programmes } + if channelNumberRegex(tvChann.ID) { + xTVChan.Number, _ = strconv.Atoi(tvChann.ID) + } displayNames := []string{} for _, displayName := range tvChann.DisplayNames { displayNames = append(displayNames, displayName.Value) } sort.StringSlice(displayNames).Sort() for i := 0; i < 10; i++ { - iterateDisplayNames(displayNames, &xTVChan) + iterateDisplayNames(displayNames, xTVChan) } - if xTVChan.Number == 0 { - xTVChan.Number = startManualNumber + 1 - startManualNumber = xTVChan.Number - xTVChan.NumberAssigned = true + channelMap[xTVChan.ID] = *xTVChan + // Duplicate this to first display-name just in case the M3U and XMLTV differ significantly. + for _, dn := range tvChann.DisplayNames { + channelMap[dn.Value] = *xTVChan } - channelMap[xTVChan.ID] = xTVChan } + return channelMap, nil } @@ -408,9 +463,9 @@ func iterateDisplayNames(displayNames []string, xTVChan *xmlTVChannel) { } } -func contains(s []string, e string) bool { +func channelExists(s []HDHomeRunChannel, e HDHomeRunChannel) bool { for _, a := range s { - if a == e { + if a.GuideName == e.GuideName { return true } } diff --git a/main.go b/main.go index 7ae1f7d..cf12e1a 100644 --- a/main.go +++ b/main.go @@ -2,6 +2,7 @@ package main import ( "fmt" + "os" "regexp" "strings" @@ -14,8 +15,15 @@ import ( var ( namespace = "telly" namespaceWithVersion = fmt.Sprintf("%s %s", namespace, version.Version) - log = logrus.New() - opts = config{} + log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } + opts = config{} exposedChannels = prometheus.NewGauge( prometheus.GaugeOpts{ @@ -55,7 +63,7 @@ func main() { kingpin.Flag("discovery.ssdp", "Turn on SSDP announcement of telly to the local network $(TELLY_DISCOVERY_SSDP)").Envar("TELLY_DISCOVERY_SSDP").Default("true").BoolVar(&opts.SSDP) // Regex/filtering flags - kingpin.Flag("filter.regex-inclusive", "Whether the provided regex is inclusive (whitelisting) or exclusive (blacklisting). If true (--filter.regex-inclusive), only channels matching the provided regex pattern will be exposed. If false (--no-filter.regex-inclusive), only channels NOT matching the provided pattern will be exposed. $(TELLY_FILTER_REGEX_MODE)").Envar("TELLY_FILTER_REGEX_MODE").Default("false").BoolVar(&opts.RegexInclusive) + kingpin.Flag("filter.regex-inclusive", "Whether the provided regex is inclusive (whitelisting) or exclusive (blacklisting). If true (--filter.regex-inclusive), only channels matching the provided regex pattern will be exposed. If false (--no-filter.regex-inclusive), only channels NOT matching the provided pattern will be exposed. $(TELLY_FILTER_REGEX_INCLUSIVE)").Envar("TELLY_FILTER_REGEX_INCLUSIVE").Default("false").BoolVar(&opts.RegexInclusive) kingpin.Flag("filter.regex", "Use regex to filter for channels that you want. A basic example would be .*UK.*. $(TELLY_FILTER_REGEX)").Envar("TELLY_FILTER_REGEX").Default(".*").RegexpVar(&opts.Regex) // Web flags @@ -67,10 +75,10 @@ func main() { kingpin.Flag("log.requests", "Log HTTP requests $(TELLY_LOG_REQUESTS)").Envar("TELLY_LOG_REQUESTS").Default("false").BoolVar(&opts.LogRequests) // IPTV flags - kingpin.Flag("iptv.playlist", "Location of playlist M3U file. Can be on disk or a URL. $(TELLY_IPTV_PLAYLIST)").Envar("TELLY_IPTV_PLAYLIST").Default("iptv.m3u").StringsVar(&opts.Playlists) + kingpin.Flag("iptv.playlist", "Path to an M3U file and optionally, a XMLTV file. Combine both strings with a semi-colon (;) for this functionality. Paths can be on disk or a URL. This flag can be used multiple times. $(TELLY_IPTV_PLAYLIST)").Envar("TELLY_IPTV_PLAYLIST").Default("iptv.m3u").StringsVar(&opts.Playlists) kingpin.Flag("iptv.streams", "Number of concurrent streams allowed $(TELLY_IPTV_STREAMS)").Envar("TELLY_IPTV_STREAMS").Default("1").IntVar(&opts.ConcurrentStreams) - kingpin.Flag("iptv.direct", "If true, stream URLs will not be obfuscated to hide them from Plex. $(TELLY_IPTV_DIRECT)").Envar("TELLY_IPTV_DIRECT").Default("false").BoolVar(&opts.DirectMode) kingpin.Flag("iptv.starting-channel", "The channel number to start exposing from. $(TELLY_IPTV_STARTING_CHANNEL)").Envar("TELLY_IPTV_STARTING_CHANNEL").Default("10000").IntVar(&opts.StartingChannel) + kingpin.Flag("iptv.xmltv-channels", "Use channel numbers discovered via XMLTV file, if provided. $(TELLY_IPTV_XMLTV_CHANNELS)").Envar("TELLY_IPTV_XMLTV_CHANNELS").Default("true").BoolVar(&opts.XMLTVChannelNumbers) kingpin.Version(version.Print("telly")) kingpin.HelpFlag.Short('h') diff --git a/routes.go b/routes.go index b952698..0350426 100644 --- a/routes.go +++ b/routes.go @@ -1,7 +1,7 @@ package main import ( - "encoding/base64" + "encoding/xml" "fmt" "net/http" "sort" @@ -35,12 +35,24 @@ func serve(opts config) { router.GET("/", deviceXML(upnp)) router.GET("/discover.json", discovery(discoveryData)) - router.GET("/lineup_status.json", lineupStatus(LineupStatus{ - ScanInProgress: convertibleBoolean(opts.lineup.Refreshing), - ScanPossible: convertibleBoolean(true), - Source: "Cable", - SourceList: []string{"Cable"}, - })) + router.GET("/lineup_status.json", func(c *gin.Context) { + payload := LineupStatus{ + ScanInProgress: convertibleBoolean(false), + ScanPossible: convertibleBoolean(true), + Source: "Cable", + SourceList: []string{"Cable"}, + } + if opts.lineup.Refreshing { + payload = LineupStatus{ + ScanInProgress: convertibleBoolean(true), + // Gotta fake out Plex. + Progress: 50, + Found: 50, + } + } + + c.JSON(http.StatusOK, payload) + }) router.POST("/lineup.post", func(c *gin.Context) { scanAction := c.Query("scan") if scanAction == "start" { @@ -57,7 +69,7 @@ func serve(opts config) { }) router.GET("/device.xml", deviceXML(upnp)) router.GET("/lineup.json", lineup(opts.lineup)) - router.GET("/stream/:channelID", stream) + router.GET("/auto/:channelID", stream(opts.lineup)) router.GET("/epg.xml", xmlTV(opts.lineup)) router.GET("/debug.json", func(c *gin.Context) { c.JSON(http.StatusOK, opts.lineup) @@ -107,25 +119,22 @@ func lineup(lineup *Lineup) gin.HandlerFunc { func xmlTV(lineup *Lineup) gin.HandlerFunc { return func(c *gin.Context) { - c.XML(http.StatusOK, lineup.xmlTv) + buf, _ := xml.MarshalIndent(lineup.xmlTv, "", "\t") + c.Data(http.StatusOK, "application/xml", []byte(xml.Header+``+"\n"+string(buf))) } } -func stream(c *gin.Context) { - - channelID := c.Param("channelID") - - log.Debugf("Parsing URI %s to %s", c.Request.RequestURI, channelID) +func stream(lineup *Lineup) gin.HandlerFunc { + return func(c *gin.Context) { + channelID := c.Param("channelID")[1:] - decodedStreamURI, decodeErr := base64.StdEncoding.DecodeString(channelID) - if decodeErr != nil { - log.WithError(decodeErr).Errorf("Invalid base64: %s", channelID) - c.AbortWithError(http.StatusBadRequest, decodeErr) - return + if url, ok := lineup.chanNumToURLMap[channelID]; ok { + log.Infof("Serving channel number %s", channelID) + c.Redirect(http.StatusMovedPermanently, url) + return + } + c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %s", channelID)) } - - log.Debugln("Redirecting to:", string(decodedStreamURI)) - c.Redirect(http.StatusMovedPermanently, string(decodedStreamURI)) } func ginrus() gin.HandlerFunc { diff --git a/structs.go b/structs.go index c2d6110..23c014c 100644 --- a/structs.go +++ b/structs.go @@ -13,10 +13,10 @@ type config struct { RegexInclusive bool Regex *regexp.Regexp - DirectMode bool - Playlists []string - ConcurrentStreams int - StartingChannel int + Playlists []string + ConcurrentStreams int + StartingChannel int + XMLTVChannelNumbers bool DeviceAuth string DeviceID int @@ -87,9 +87,11 @@ func (d *DiscoveryData) UPNP() UPNP { // LineupStatus exposes the status of the channel lineup. type LineupStatus struct { ScanInProgress convertibleBoolean - ScanPossible convertibleBoolean - Source string - SourceList []string + ScanPossible convertibleBoolean `json:",omitempty"` + Source string `json:",omitempty"` + SourceList []string `json:",omitempty"` + Progress int `json:",omitempty"` // Percent complete + Found int `json:",omitempty"` // Number of found channels } type upnpVersion struct { diff --git a/xmltv/xmltv.go b/xmltv/xmltv.go index 6795f43..911c275 100644 --- a/xmltv/xmltv.go +++ b/xmltv/xmltv.go @@ -35,6 +35,7 @@ func (t *Time) UnmarshalXMLAttr(attr xml.Attr) error { // TV is the root element. type TV struct { + XMLName xml.Name `xml:"tv" json:"-"` Channels []Channel `xml:"channel" json:"channels"` Programmes []Programme `xml:"programme" json:"programmes"` Date string `xml:"date,attr,omitempty" json:"date,omitempty"` @@ -88,7 +89,7 @@ type Programme struct { PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` - New ElementPresent `xml:"new" json:"new"` + New ElementPresent `xml:"new>placeholder,omitempty" json:"new"` Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` @@ -101,6 +102,10 @@ type Programme struct { Videoplus string `xml:"videoplus,attr,omitempty" json:"videoplus,omitempty"` Channel string `xml:"channel,attr" json:"channel"` Clumpidx string `xml:"clumpidx,attr,omitempty" json:"clumpidx,omitempty"` + + // These fields are outside of the XMLTV spec. + // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. + LCN int `xml:"lcn,attr" json:"lcn,omitempty"` } // CommonElement element structure that is common, i.e. Italy @@ -112,6 +117,11 @@ type CommonElement struct { // ElementPresent used to determine if element is present or not type ElementPresent bool +// MarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 +func (c *ElementPresent) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + return e.EncodeElement(*c, start) +} + // UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 func (c *ElementPresent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { var v string @@ -124,9 +134,9 @@ func (c *ElementPresent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) er // Icon associated with the element that contains it type Icon struct { - Source string `xml:"src,attr" json:"source"` - Width int `xml:"width,attr" json:"width"` - Height int `xml:"height,attr" json:"height"` + Source string `xml:"src,attr" json:"source"` + Width int `xml:"width,attr,omitempty" json:"width,omitempty"` + Height int `xml:"height,attr,omitempty" json:"height,omitempty"` } // Credits for the programme From 952cbc74b1ec6f8327ce8889053b2fd6c3960ebf Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 14 Aug 2018 17:01:54 -0700 Subject: [PATCH 006/182] Checkpoint before redoing Lineup --- lineup.go | 72 ++++++++++++++++--------- main.go | 115 +++++++++++++++++++++++++--------------- providers/eternal.go | 4 ++ providers/hellraiser.go | 4 ++ providers/iptv-epg.go | 4 ++ providers/main.go | 97 +++++++++++++++++++++++++++++++++ providers/tnt.go | 4 ++ providers/vaders.go | 72 +++++++++++++++++++++++++ routes.go | 30 +++++------ structs.go | 67 +++++++++++------------ utils.go | 34 ++++++++++++ 11 files changed, 386 insertions(+), 117 deletions(-) create mode 100644 providers/eternal.go create mode 100644 providers/hellraiser.go create mode 100644 providers/iptv-epg.go create mode 100644 providers/main.go create mode 100644 providers/tnt.go create mode 100644 providers/vaders.go create mode 100644 utils.go diff --git a/lineup.go b/lineup.go index bbfbb87..4b3badb 100644 --- a/lineup.go +++ b/lineup.go @@ -12,7 +12,9 @@ import ( "strings" "time" + "github.com/spf13/viper" "github.com/tombowditch/telly/m3u" + "github.com/tombowditch/telly/providers" "github.com/tombowditch/telly/xmltv" ) @@ -74,7 +76,7 @@ func (p *Playlist) Filter() error { return unmarshalErr } - if opts.Regex.MatchString(track.Raw) == opts.RegexInclusive { + if GetStringAsRegex("filter.regexstr").MatchString(track.Raw) == viper.GetBool("filter.regexinclusive") { p.Tracks = append(p.Tracks, track) } } @@ -105,6 +107,8 @@ type HDHomeRunChannel struct { // Lineup is a collection of tracks type Lineup struct { + Providers []providers.Provider + Playlists []Playlist PlaylistsCount int TracksCount int @@ -128,32 +132,46 @@ type Lineup struct { } // NewLineup returns a new Lineup for the given config struct. -func NewLineup(opts config) *Lineup { +func NewLineup() *Lineup { tv := xmltv.TV{ GeneratorInfoName: namespaceWithVersion, GeneratorInfoURL: "https://github.com/tombowditch/telly", } lineup := &Lineup{ - xmlTVChannelNumbers: opts.XMLTVChannelNumbers, + xmlTVChannelNumbers: viper.GetBool("iptv.xmltv-channels"), chanNumToURLMap: make(map[string]string), xmlTv: tv, xmlTvChannelMap: make(map[string]xmlTVChannel), - StartingChannelNumber: opts.StartingChannel, - channelNumber: opts.StartingChannel, + StartingChannelNumber: viper.GetInt("iptv.starting-channel"), + channelNumber: viper.GetInt("iptv.starting-channel"), Refreshing: false, LastRefreshed: time.Now(), } + var cfgs []providers.Configuration + + if unmarshalErr := viper.UnmarshalKey("source", &cfgs); unmarshalErr != nil { + log.WithError(unmarshalErr).Panicln("Unable to unmarshal source configuration to slice of providers.Configuration, check your configuration!") + } + + for _, cfg := range cfgs { + log.Infoln("Adding provider", cfg.Name) + provider, providerErr := cfg.GetProvider() + if providerErr != nil { + panic(providerErr) + } + if addErr := lineup.AddProvider(provider); addErr != nil { + log.WithError(addErr).Panicln("error adding new provider to lineup") + } + } + return lineup } -// AddPlaylist adds a new playlist to the Lineup. -func (l *Lineup) AddPlaylist(plist string) error { - // Attempt to split the string by semi colon for complex config passing with m3uPath,xmlPath,name - splitStr := strings.Split(plist, ";") - path := splitStr[0] - reader, info, readErr := l.getM3U(path) +// AddProvider adds a new Provider to the Lineup. +func (l *Lineup) AddProvider(provider providers.Provider) error { + reader, info, readErr := l.getM3U(provider.PlaylistURL()) if readErr != nil { log.WithError(readErr).Errorln("error getting m3u") return readErr @@ -165,8 +183,8 @@ func (l *Lineup) AddPlaylist(plist string) error { return err } - if len(splitStr) > 1 { - epg, epgReadErr := l.getXMLTV(splitStr[1]) + if provider.EPGURL() != "" { + epg, epgReadErr := l.getXMLTV(provider.EPGURL()) if epgReadErr != nil { log.WithError(epgReadErr).Errorln("error getting XMLTV") return epgReadErr @@ -182,7 +200,7 @@ func (l *Lineup) AddPlaylist(plist string) error { } } - playlist, playlistErr := l.NewPlaylist(rawPlaylist, info, (len(splitStr) > 1)) + playlist, playlistErr := l.NewPlaylist(provider, rawPlaylist, info) if playlistErr != nil { return playlistErr } @@ -196,7 +214,8 @@ func (l *Lineup) AddPlaylist(plist string) error { } // NewPlaylist will return a new and filtered Playlist for the given m3u.Playlist and M3UFile. -func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile, hasEPG bool) (Playlist, error) { +func (l *Lineup) NewPlaylist(provider providers.Provider, rawPlaylist *m3u.Playlist, info *M3UFile) (Playlist, error) { + hasEPG := provider.EPGURL() != "" playlist := Playlist{rawPlaylist, info, nil, nil, len(rawPlaylist.Tracks), 0, hasEPG} if filterErr := playlist.Filter(); filterErr != nil { @@ -205,7 +224,7 @@ func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile, hasEPG bo } for idx, track := range playlist.Tracks { - tt, channelNumber, hd, ttErr := l.processTrack(hasEPG, track) + tt, channelNumber, hd, ttErr := l.processTrack(provider, track) if ttErr != nil { return playlist, ttErr } @@ -224,7 +243,7 @@ func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile, hasEPG bo hdhr := HDHomeRunChannel{ GuideNumber: channelNumber, GuideName: guideName, - URL: fmt.Sprintf("http://%s/auto/v%d", opts.BaseAddress.String(), channelNumber), + URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), channelNumber), HD: convertibleBoolean(hd), DRM: convertibleBoolean(false), } @@ -253,9 +272,11 @@ func (l *Lineup) NewPlaylist(rawPlaylist *m3u.Playlist, info *M3UFile, hasEPG bo return playlist, nil } -func (l Lineup) processTrack(hasEPG bool, track Track) (*Track, int, bool, error) { +func (l Lineup) processTrack(provider providers.Provider, track Track) (*Track, int, bool, error) { + hd := hdRegex.MatchString(strings.ToLower(track.Track.Raw)) channelNumber := l.channelNumber + if xmlChan, ok := l.xmlTvChannelMap[track.TvgID]; ok { log.Debugln("found an entry in xmlTvChannelMap for", track.Name) if l.xmlTVChannelNumbers && xmlChan.Number != 0 { @@ -308,11 +329,12 @@ func (l Lineup) Refresh() error { l.FilteredTracksCount = 0 l.StartingChannelNumber = 0 - for _, playlist := range existingPlaylists { - if addErr := l.AddPlaylist(playlist.M3UFile.Path); addErr != nil { - return addErr - } - } + // FIXME: Re-implement AddProvider to use a provider. + // for _, playlist := range existingPlaylists { + // if addErr := l.AddProvider(playlist.M3UFile.Path); addErr != nil { + // return addErr + // } + // } log.Infoln("Done refreshing the lineup!") @@ -428,7 +450,7 @@ func (l *Lineup) processXMLTV(tv *xmltv.TV) (map[string]xmlTVChannel, error) { } sort.StringSlice(displayNames).Sort() for i := 0; i < 10; i++ { - iterateDisplayNames(displayNames, xTVChan) + extractDisplayNames(displayNames, xTVChan) } channelMap[xTVChan.ID] = *xTVChan // Duplicate this to first display-name just in case the M3U and XMLTV differ significantly. @@ -440,7 +462,7 @@ func (l *Lineup) processXMLTV(tv *xmltv.TV) (map[string]xmlTVChannel, error) { return channelMap, nil } -func iterateDisplayNames(displayNames []string, xTVChan *xmlTVChannel) { +func extractDisplayNames(displayNames []string, xTVChan *xmlTVChannel) { for _, displayName := range displayNames { if channelNumberRegex(displayName) { if chanNum, chanNumErr := strconv.Atoi(displayName); chanNumErr == nil { diff --git a/main.go b/main.go index cf12e1a..7746d66 100644 --- a/main.go +++ b/main.go @@ -1,7 +1,10 @@ package main import ( + "encoding/json" + fflag "flag" "fmt" + "net" "os" "regexp" "strings" @@ -9,7 +12,8 @@ import ( "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/common/version" "github.com/sirupsen/logrus" - kingpin "gopkg.in/alecthomas/kingpin.v2" + flag "github.com/spf13/pflag" + "github.com/spf13/viper" ) var ( @@ -53,76 +57,103 @@ var ( func main() { // Discovery flags - kingpin.Flag("discovery.device-id", "8 digits used to uniquely identify the device. $(TELLY_DISCOVERY_DEVICE_ID)").Envar("TELLY_DISCOVERY_DEVICE_ID").Default("12345678").IntVar(&opts.DeviceID) - kingpin.Flag("discovery.device-friendly-name", "Name exposed via discovery. Useful if you are running two instances of telly and want to differentiate between them $(TELLY_DISCOVERY_DEVICE_FRIENDLY_NAME)").Envar("TELLY_DISCOVERY_DEVICE_FRIENDLY_NAME").Default("telly").StringVar(&opts.FriendlyName) - kingpin.Flag("discovery.device-auth", "Only change this if you know what you're doing $(TELLY_DISCOVERY_DEVICE_AUTH)").Envar("TELLY_DISCOVERY_DEVICE_AUTH").Default("telly123").Hidden().StringVar(&opts.DeviceAuth) - kingpin.Flag("discovery.device-manufacturer", "Manufacturer exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MANUFACTURER)").Envar("TELLY_DISCOVERY_DEVICE_MANUFACTURER").Default("Silicondust").StringVar(&opts.Manufacturer) - kingpin.Flag("discovery.device-model-number", "Model number exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MODEL_NUMBER)").Envar("TELLY_DISCOVERY_DEVICE_MODEL_NUMBER").Default("HDTC-2US").StringVar(&opts.ModelNumber) - kingpin.Flag("discovery.device-firmware-name", "Firmware name exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_NAME)").Envar("TELLY_DISCOVERY_DEVICE_FIRMWARE_NAME").Default("hdhomeruntc_atsc").StringVar(&opts.FirmwareName) - kingpin.Flag("discovery.device-firmware-version", "Firmware version exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_VERSION)").Envar("TELLY_DISCOVERY_DEVICE_FIRMWARE_VERSION").Default("20150826").StringVar(&opts.FirmwareVersion) - kingpin.Flag("discovery.ssdp", "Turn on SSDP announcement of telly to the local network $(TELLY_DISCOVERY_SSDP)").Envar("TELLY_DISCOVERY_SSDP").Default("true").BoolVar(&opts.SSDP) + flag.Int("discovery.device-id", 12345678, "8 digits used to uniquely identify the device. $(TELLY_DISCOVERY_DEVICE_ID)") + flag.String("discovery.device-friendly-name", "telly", "Name exposed via discovery. Useful if you are running two instances of telly and want to differentiate between them $(TELLY_DISCOVERY_DEVICE_FRIENDLY_NAME)") + flag.String("discovery.device-auth", "telly123", "Only change this if you know what you're doing $(TELLY_DISCOVERY_DEVICE_AUTH)") + flag.String("discovery.device-manufacturer", "Silicondust", "Manufacturer exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MANUFACTURER)") + flag.String("discovery.device-model-number", "HDTC-2US", "Model number exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MODEL_NUMBER)") + flag.String("discovery.device-firmware-name", "hdhomeruntc_atsc", "Firmware name exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_NAME)") + flag.String("discovery.device-firmware-version", "20150826", "Firmware version exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_VERSION)") + flag.Bool("discovery.ssdp", true, "Turn on SSDP announcement of telly to the local network $(TELLY_DISCOVERY_SSDP)") // Regex/filtering flags - kingpin.Flag("filter.regex-inclusive", "Whether the provided regex is inclusive (whitelisting) or exclusive (blacklisting). If true (--filter.regex-inclusive), only channels matching the provided regex pattern will be exposed. If false (--no-filter.regex-inclusive), only channels NOT matching the provided pattern will be exposed. $(TELLY_FILTER_REGEX_INCLUSIVE)").Envar("TELLY_FILTER_REGEX_INCLUSIVE").Default("false").BoolVar(&opts.RegexInclusive) - kingpin.Flag("filter.regex", "Use regex to filter for channels that you want. A basic example would be .*UK.*. $(TELLY_FILTER_REGEX)").Envar("TELLY_FILTER_REGEX").Default(".*").RegexpVar(&opts.Regex) + flag.Bool("filter.regex-inclusive", false, "Whether the provided regex is inclusive (whitelisting) or exclusive (blacklisting). If true (--filter.regex-inclusive), only channels matching the provided regex pattern will be exposed. If false (--no-filter.regex-inclusive), only channels NOT matching the provided pattern will be exposed. $(TELLY_FILTER_REGEX_INCLUSIVE)") + flag.String("filter.regex", ".*", "Use regex to filter for channels that you want. A basic example would be .*UK.*. $(TELLY_FILTER_REGEX)") // Web flags - kingpin.Flag("web.listen-address", "Address to listen on for web interface and telemetry $(TELLY_WEB_LISTEN_ADDRESS)").Envar("TELLY_WEB_LISTEN_ADDRESS").Default("localhost:6077").TCPVar(&opts.ListenAddress) - kingpin.Flag("web.base-address", "The address to expose via discovery. Useful with reverse proxy $(TELLY_WEB_BASE_ADDRESS)").Envar("TELLY_WEB_BASE_ADDRESS").Default("localhost:6077").TCPVar(&opts.BaseAddress) + flag.String("web.listen-address", "localhost:6077", "Address to listen on for web interface and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") + flag.String("web.base-address", "localhost:6077", "The address to expose via discovery. Useful with reverse proxy $(TELLY_WEB_BASE_ADDRESS)") // Log flags - kingpin.Flag("log.level", "Only log messages with the given severity or above. Valid levels: [debug, info, warn, error, fatal] $(TELLY_LOG_LEVEL)").Envar("TELLY_LOG_LEVEL").Default(logrus.InfoLevel.String()).StringVar(&opts.LogLevel) - kingpin.Flag("log.requests", "Log HTTP requests $(TELLY_LOG_REQUESTS)").Envar("TELLY_LOG_REQUESTS").Default("false").BoolVar(&opts.LogRequests) + flag.String("log.level", logrus.InfoLevel.String(), "Only log messages with the given severity or above. Valid levels: [debug, info, warn, error, fatal] $(TELLY_LOG_LEVEL)") + flag.Bool("log.requests", false, "Log HTTP requests $(TELLY_LOG_REQUESTS)") // IPTV flags - kingpin.Flag("iptv.playlist", "Path to an M3U file and optionally, a XMLTV file. Combine both strings with a semi-colon (;) for this functionality. Paths can be on disk or a URL. This flag can be used multiple times. $(TELLY_IPTV_PLAYLIST)").Envar("TELLY_IPTV_PLAYLIST").Default("iptv.m3u").StringsVar(&opts.Playlists) - kingpin.Flag("iptv.streams", "Number of concurrent streams allowed $(TELLY_IPTV_STREAMS)").Envar("TELLY_IPTV_STREAMS").Default("1").IntVar(&opts.ConcurrentStreams) - kingpin.Flag("iptv.starting-channel", "The channel number to start exposing from. $(TELLY_IPTV_STARTING_CHANNEL)").Envar("TELLY_IPTV_STARTING_CHANNEL").Default("10000").IntVar(&opts.StartingChannel) - kingpin.Flag("iptv.xmltv-channels", "Use channel numbers discovered via XMLTV file, if provided. $(TELLY_IPTV_XMLTV_CHANNELS)").Envar("TELLY_IPTV_XMLTV_CHANNELS").Default("true").BoolVar(&opts.XMLTVChannelNumbers) - - kingpin.Version(version.Print("telly")) - kingpin.HelpFlag.Short('h') - kingpin.Parse() + flag.String("iptv.playlist", "", "Path to an M3U file on disk or at a URL. $(TELLY_IPTV_PLAYLIST)") + flag.Int("iptv.streams", 1, "Number of concurrent streams allowed $(TELLY_IPTV_STREAMS)") + flag.Int("iptv.starting-channel", 10000, "The channel number to start exposing from. $(TELLY_IPTV_STARTING_CHANNEL)") + flag.Bool("iptv.xmltv-channels", true, "Use channel numbers discovered via XMLTV file, if provided. $(TELLY_IPTV_XMLTV_CHANNELS)") + + flag.CommandLine.AddGoFlagSet(fflag.CommandLine) + flag.Parse() + viper.BindPFlags(flag.CommandLine) + viper.SetConfigName("telly.config") // name of config file (without extension) + viper.AddConfigPath("/etc/telly/") // path to look for the config file in + viper.AddConfigPath("$HOME/.telly") // call multiple times to add many search paths + viper.AddConfigPath(".") // optionally look for config in the working directory + viper.SetEnvPrefix(namespace) + viper.AutomaticEnv() + err := viper.ReadInConfig() // Find and read the config file + if err != nil { // Handle errors reading the config file + if _, ok := err.(viper.ConfigFileNotFoundError); !ok { + log.WithError(err).Panicln("fatal error while reading config file:") + } + } log.Infoln("Starting telly", version.Info()) log.Infoln("Build context", version.BuildContext()) prometheus.MustRegister(version.NewCollector("telly"), exposedChannels) - level, parseLevelErr := logrus.ParseLevel(opts.LogLevel) + level, parseLevelErr := logrus.ParseLevel(viper.GetString("log.level")) if parseLevelErr != nil { log.WithError(parseLevelErr).Panicln("error setting log level!") } log.SetLevel(level) - opts.FriendlyName = fmt.Sprintf("HDHomerun (%s)", opts.FriendlyName) - opts.DeviceUUID = fmt.Sprintf("%d-AE2A-4E54-BBC9-33AF7D5D6A92", opts.DeviceID) + if log.Level == logrus.DebugLevel { + js, _ := json.MarshalIndent(viper.AllSettings(), "", " ") + log.Debugf("Loaded configuration %s", js) + } - if opts.BaseAddress.IP.IsUnspecified() { - log.Panicln("base URL is set to 0.0.0.0, this will not work. please use the --web.base-address option and set it to the (local) ip address telly is running on.") + if viper.IsSet("filter.regexstr") { + if _, regexErr := regexp.Compile(viper.GetString("filter.regex")); regexErr != nil { + log.WithError(regexErr).Panicln("Error when compiling regex, is it valid?") + } } - if opts.ListenAddress.IP.IsUnspecified() && opts.BaseAddress.IP.IsLoopback() { - log.Warnln("You are listening on all interfaces but your base URL is localhost (meaning Plex will try and load localhost to access your streams) - is this intended?") + var addrErr error + if _, addrErr = net.ResolveTCPAddr("tcp", viper.GetString("web.listenaddress")); addrErr != nil { + log.WithError(addrErr).Panic("Error when parsing Listen address, please check the address and try again.") + return + } + if _, addrErr = net.ResolveTCPAddr("tcp", viper.GetString("web.base-address")); addrErr != nil { + log.WithError(addrErr).Panic("Error when parsing Base addresses, please check the address and try again.") + return } - if len(opts.Playlists) == 1 && opts.Playlists[0] == "iptv.m3u" { - log.Warnln("using default m3u option, 'iptv.m3u'. launch telly with the --iptv.playlist=yourfile.m3u option to change this!") + if GetTCPAddr("web.base-address").IP.IsUnspecified() { + log.Panicln("base URL is set to 0.0.0.0, this will not work. please use the --web.baseaddress option and set it to the (local) ip address telly is running on.") } - opts.lineup = NewLineup(opts) + if GetTCPAddr("web.listenaddress").IP.IsUnspecified() && GetTCPAddr("web.base-address").IP.IsLoopback() { + log.Warnln("You are listening on all interfaces but your base URL is localhost (meaning Plex will try and load localhost to access your streams) - is this intended?") + } - for _, playlistPath := range opts.Playlists { - if addErr := opts.lineup.AddPlaylist(playlistPath); addErr != nil { - log.WithError(addErr).Panicln("error adding new playlist to lineup") - } + viper.Set("discovery.device-friendly-name", fmt.Sprintf("HDHomerun (%s)", viper.GetString("discovery.device-friendly-name"))) + viper.Set("discovery.device-uuid", fmt.Sprintf("%d-AE2A-4E54-BBC9-33AF7D5D6A92", viper.GetInt("discovery.device-id"))) + + if flag.Lookup("iptv.playlist").Changed { + viper.Set("playlists.default.m3u", flag.Lookup("iptv.playlist").Value.String()) } - log.Infof("Loaded %d channels into the lineup", opts.lineup.FilteredTracksCount) + lineup := NewLineup() + + log.Infof("Loaded %d channels into the lineup", lineup.FilteredTracksCount) - // if opts.lineup.FilteredTracksCount > 420 { - // log.Panicln("telly has loaded more than 420 channels into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You must use regular expressions to filter out channels. You can also start another Telly instance.") - // } + if lineup.FilteredTracksCount > 420 { + log.Panicf("telly has loaded more than 420 channels (%d) into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You must use regular expressions to filter out channels. You can also start another Telly instance.", lineup.FilteredTracksCount) + } - serve(opts) + serve(lineup) } diff --git a/providers/eternal.go b/providers/eternal.go new file mode 100644 index 0000000..fc59a4f --- /dev/null +++ b/providers/eternal.go @@ -0,0 +1,4 @@ +package providers + +// M3U:http://live.eternaltv.net:25461/get.php?username=xxxxxxx&password=xxxxxx&output=ts&type=m3u_plus +// XMLTV: http://live.eternaltv.net:25461/xmltv.php?username=xxxxx&password=xxxxx&type=m3u_plus&output=ts diff --git a/providers/hellraiser.go b/providers/hellraiser.go new file mode 100644 index 0000000..de264a8 --- /dev/null +++ b/providers/hellraiser.go @@ -0,0 +1,4 @@ +package providers + +// Playlist URL: http://liquidit.info:8080/get.php?username=xxxx&password=xxxxxxx&type=m3u_plus&output=ts +// XMLTV URL: http://liquidit.info:8080/xmltv.php?username=xxxxxx&password=xxxxxx diff --git a/providers/iptv-epg.go b/providers/iptv-epg.go new file mode 100644 index 0000000..d1af649 --- /dev/null +++ b/providers/iptv-epg.go @@ -0,0 +1,4 @@ +package providers + +// M3U: http://iptv-epg.com/.m3u +// XMLTV: http://iptv-epg.com/.xml diff --git a/providers/main.go b/providers/main.go new file mode 100644 index 0000000..ad7bbe3 --- /dev/null +++ b/providers/main.go @@ -0,0 +1,97 @@ +package providers + +import ( + "fmt" + "regexp" + "strings" + + log "github.com/sirupsen/logrus" + "github.com/tombowditch/telly/m3u" +) + +var channelNumberExtractor = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch + +type Configuration struct { + Name string `json:"-"` + Provider string + + Username string `json:"username"` + Password string `json:"password"` + + M3U string `json:"-"` + EPG string `json:"-"` + + VideoOnDemand bool `json:"-"` +} + +func (i *Configuration) GetProvider() (Provider, error) { + switch strings.ToLower(i.Provider) { + case "vaders": + log.Infoln("Source is vaders!") + return newVaders(i) + case "custom": + default: + log.Infoln("source is either custom or unknown, assuming custom!") + } + return nil, nil +} + +// ProviderChannel describes a channel available in the providers lineup with necessary pieces parsed into fields. +type ProviderChannel struct { + Name string + InternalID int // Should be the integer just before .ts. + Number *int + Logo string + StreamURL string + HD bool + Quality string + OnDemand bool + StreamFormat string +} + +// Provider describes a IPTV provider configuration. +type Provider interface { + Name() string + PlaylistURL() string + EPGURL() string + + // These are functions to extract information from playlists. + ParseLine(line m3u.Track) (*ProviderChannel, error) + + AuthenticatedStreamURL(channel *ProviderChannel) string + + MatchPlaylistKey() string +} + +// UnmarshalProviders takes V, a slice of Configuration and transforms it into a slice of Provider. +func UnmarshalProviders(v interface{}) ([]Provider, error) { + providers := make([]Provider, 0) + + uncasted, ok := v.([]interface{}) + if !ok { + panic(fmt.Errorf("provided slice is not of type []Configuration, it is of type %T", v)) + } + + for _, uncastedProvider := range uncasted { + ipProvider := uncastedProvider.(Configuration) + log.Infof("ipProvider %+v", ipProvider) + } + + return providers, nil +} + +// func testProvider() { +// v, vErr := NewVadersTV("hunter1", "hunter2", false) +// if vErr != nil { +// log.WithError(vErr).Errorf("Error setting up %s", v.Name()) +// } +// log.Infoln("Provider name is", v.Name()) +// log.Infoln("Playlist URL is", v.PlaylistURL()) +// log.Infoln("EPG URL is", v.EPGURL()) +// log.Infof("Stream URL is %+v", v.AuthenticatedStreamURL(&ProviderChannel{ +// Name: "Test channel", +// InternalID: 2862, +// })) + +// return +// } diff --git a/providers/tnt.go b/providers/tnt.go new file mode 100644 index 0000000..2f8295f --- /dev/null +++ b/providers/tnt.go @@ -0,0 +1,4 @@ +package providers + +// M3U: http://thesepeanutz.xyz:2052/get.php?username=xxx&password=xxx&type=m3u_plus&output=ts +// XMLTV: http://thesepeanutz.xyz:2052/xmltv.php?username=xxx&password=xxx diff --git a/providers/vaders.go b/providers/vaders.go new file mode 100644 index 0000000..a324c39 --- /dev/null +++ b/providers/vaders.go @@ -0,0 +1,72 @@ +package providers + +import ( + "encoding/base64" + "encoding/json" + "fmt" + "strconv" + "strings" + + "github.com/tombowditch/telly/m3u" +) + +// M3U: http://api.vaders.tv/vget?username=xxx&password=xxx&format=ts +// XMLTV: http://vaders.tv/p2.xml + +type vader struct { + provider Configuration + + Token string `json:"-"` +} + +func newVaders(config *Configuration) (Provider, error) { + tok, tokErr := json.Marshal(config) + if tokErr != nil { + return nil, tokErr + } + + return &vader{*config, base64.StdEncoding.EncodeToString(tok)}, nil +} + +func (v *vader) Name() string { + return "Vaders.tv" +} + +func (v *vader) PlaylistURL() string { + return fmt.Sprintf("http://api.vaders.tv/vget?username=%s&password=%s&vod=%t&format=ts", v.provider.Username, v.provider.Password, v.provider.VideoOnDemand) +} + +func (v *vader) EPGURL() string { + return "http://vaders.tv/p2.xml" +} + +func (v *vader) ParseLine(line m3u.Track) (*ProviderChannel, error) { + streamURL := channelNumberExtractor(line.URI, -1)[0] + channelID, channelIDErr := strconv.Atoi(streamURL[1]) + if channelIDErr != nil { + return nil, channelIDErr + } + + // http://vapi.vaders.tv/play/dvr/${start}/TSID.ts?duration=3600&token= + // http://vapi.vaders.tv/play/TSID.ts?token= + // http://vapi.vaders.tv/play/vod/VODID.mp4.m3u8?token= + // http://vapi.vaders.tv/play/vod/VODID.avi.m3u8?token= + // http://vapi.vaders.tv/play/vod/VODID.mkv.m3u8?token= + + return &ProviderChannel{ + Name: line.Tags["tvg-name"], + Logo: line.Tags["tvg-logo"], + StreamURL: line.URI, + InternalID: channelID, + HD: strings.Contains(strings.ToLower(line.Tags["tvg-name"]), "hd"), + StreamFormat: streamURL[2], + }, nil +} + +func (v *vader) AuthenticatedStreamURL(channel *ProviderChannel) string { + return fmt.Sprintf("http://vapi.vaders.tv/play/%d.ts?token=%s", channel.InternalID, v.Token) +} + +func (v *vader) MatchPlaylistKey() string { + return "tvg-id" +} diff --git a/routes.go b/routes.go index 0350426..26a2012 100644 --- a/routes.go +++ b/routes.go @@ -10,11 +10,12 @@ import ( "github.com/gin-gonic/gin" ssdp "github.com/koron/go-ssdp" "github.com/sirupsen/logrus" + "github.com/spf13/viper" ginprometheus "github.com/zsais/go-gin-prometheus" ) -func serve(opts config) { - discoveryData := opts.DiscoveryData() +func serve(lineup *Lineup) { + discoveryData := GetDiscoveryData() log.Debugln("creating device xml") upnp := discoveryData.UPNP() @@ -26,7 +27,7 @@ func serve(opts config) { router := gin.New() router.Use(gin.Recovery()) - if opts.LogRequests { + if viper.GetBool("log.logrequests") { router.Use(ginrus()) } @@ -42,7 +43,7 @@ func serve(opts config) { Source: "Cable", SourceList: []string{"Cable"}, } - if opts.lineup.Refreshing { + if lineup.Refreshing { payload = LineupStatus{ ScanInProgress: convertibleBoolean(true), // Gotta fake out Plex. @@ -56,7 +57,7 @@ func serve(opts config) { router.POST("/lineup.post", func(c *gin.Context) { scanAction := c.Query("scan") if scanAction == "start" { - if refreshErr := opts.lineup.Refresh(); refreshErr != nil { + if refreshErr := lineup.Refresh(); refreshErr != nil { c.AbortWithError(http.StatusInternalServerError, refreshErr) } c.AbortWithStatus(http.StatusOK) @@ -68,22 +69,21 @@ func serve(opts config) { c.String(http.StatusBadRequest, "%s is not a valid scan command", scanAction) }) router.GET("/device.xml", deviceXML(upnp)) - router.GET("/lineup.json", lineup(opts.lineup)) - router.GET("/auto/:channelID", stream(opts.lineup)) - router.GET("/epg.xml", xmlTV(opts.lineup)) + router.GET("/lineup.json", serveLineup(lineup)) + router.GET("/auto/:channelID", stream(lineup)) + router.GET("/epg.xml", xmlTV(lineup)) router.GET("/debug.json", func(c *gin.Context) { - c.JSON(http.StatusOK, opts.lineup) + c.JSON(http.StatusOK, lineup) }) - if opts.SSDP { - log.Debugln("advertising telly service on network via UPNP/SSDP") - if _, ssdpErr := setupSSDP(opts.BaseAddress.String(), opts.FriendlyName, opts.DeviceUUID); ssdpErr != nil { + if viper.GetBool("discovery.ssdp") { + if _, ssdpErr := setupSSDP(viper.GetString("web.base-address"), viper.GetString("discovery.device-friendly-name"), viper.GetString("discovery.device-uuid")); ssdpErr != nil { log.WithError(ssdpErr).Errorln("telly cannot advertise over ssdp") } } - log.Infof("Listening and serving HTTP on %s", opts.ListenAddress) - if err := router.Run(opts.ListenAddress.String()); err != nil { + log.Infof("Listening and serving HTTP on %s", viper.GetString("web.listen-address")) + if err := router.Run(viper.GetString("web.listen-address")); err != nil { log.WithError(err).Panicln("Error starting up web server") } } @@ -106,7 +106,7 @@ func lineupStatus(status LineupStatus) gin.HandlerFunc { } } -func lineup(lineup *Lineup) gin.HandlerFunc { +func serveLineup(lineup *Lineup) gin.HandlerFunc { return func(c *gin.Context) { allChannels := make([]HDHomeRunChannel, 0) for _, playlist := range lineup.Playlists { diff --git a/structs.go b/structs.go index 23c014c..40d169b 100644 --- a/structs.go +++ b/structs.go @@ -6,52 +6,49 @@ import ( "fmt" "net" "regexp" - "strconv" ) type config struct { - RegexInclusive bool - Regex *regexp.Regexp + Filter struct { + RegexInclusive bool `toml:"Filter.RegexInclusive"` + Regex *regexp.Regexp `toml:"-"` + RegexStr string `toml:"Filter.Regex"` + } - Playlists []string - ConcurrentStreams int - StartingChannel int - XMLTVChannelNumbers bool + IPTV struct { + Playlists []string `toml:"IPTV.Playlists"` + ConcurrentStreams int `toml:"IPTV.ConcurrentStreams"` + StartingChannel int `toml:"IPTV.StartingChannel"` + XMLTVChannelNumbers bool `toml:"IPTV.XMLTVChannelNumbers"` + } - DeviceAuth string - DeviceID int - DeviceUUID string - FriendlyName string - Manufacturer string - ModelNumber string - FirmwareName string - FirmwareVersion string - SSDP bool + Discovery struct { + DeviceAuth string `toml:"Discovery.DeviceAuth"` + DeviceID int `toml:"Discovery.DeviceID"` + DeviceUUID string `toml:"Discovery.DeviceUUID"` + FriendlyName string `toml:"Discovery.FriendlyName"` + Manufacturer string `toml:"Discovery.Manufacturer"` + ModelNumber string `toml:"Discovery.ModelNumber"` + FirmwareName string `toml:"Discovery.FirmwareName"` + FirmwareVersion string `toml:"Discovery.FirmwareVersion"` + SSDP bool `toml:"Discovery.SSDP"` + } - LogRequests bool - LogLevel string + Log struct { + LogRequests bool `toml:"Log.Requests"` + Level string `toml:"Log.Level"` + } - ListenAddress *net.TCPAddr - BaseAddress *net.TCPAddr + Web struct { + ListenAddress *net.TCPAddr `toml:"-"` + BaseAddress *net.TCPAddr `toml:"-"` + ListenAddressStr string `toml:"Web.ListenAddress"` + BaseAddressStr string `toml:"Web.BaseAddress"` + } lineup *Lineup } -func (c *config) DiscoveryData() DiscoveryData { - return DiscoveryData{ - FriendlyName: c.FriendlyName, - Manufacturer: c.Manufacturer, - ModelNumber: c.ModelNumber, - FirmwareName: c.FirmwareName, - TunerCount: c.ConcurrentStreams, - FirmwareVersion: c.FirmwareVersion, - DeviceID: strconv.Itoa(c.DeviceID), - DeviceAuth: c.DeviceAuth, - BaseURL: fmt.Sprintf("http://%s", c.BaseAddress), - LineupURL: fmt.Sprintf("http://%s/lineup.json", c.BaseAddress), - } -} - // DiscoveryData contains data about telly to expose in the HDHomeRun format for Plex detection. type DiscoveryData struct { FriendlyName string diff --git a/utils.go b/utils.go new file mode 100644 index 0000000..a106b96 --- /dev/null +++ b/utils.go @@ -0,0 +1,34 @@ +package main + +import ( + "fmt" + "net" + "regexp" + "strconv" + + "github.com/spf13/viper" +) + +func GetTCPAddr(key string) *net.TCPAddr { + addr, _ := net.ResolveTCPAddr("tcp", viper.GetString(key)) + return addr +} + +func GetStringAsRegex(key string) *regexp.Regexp { + return regexp.MustCompile(viper.GetString(key)) +} + +func GetDiscoveryData() DiscoveryData { + return DiscoveryData{ + FriendlyName: viper.GetString("discovery.device-friendly-name"), + Manufacturer: viper.GetString("discovery.device-manufacturer"), + ModelNumber: viper.GetString("discovery.device-model-number"), + FirmwareName: viper.GetString("discovery.device-firmware-name"), + TunerCount: viper.GetInt("iptv.concurrent-streams"), + FirmwareVersion: viper.GetString("discovery.device-firmware-version"), + DeviceID: strconv.Itoa(viper.GetInt("discovery.device-id")), + DeviceAuth: viper.GetString("discovery.device-auth"), + BaseURL: fmt.Sprintf("http://%s", viper.GetString("web.base-address")), + LineupURL: fmt.Sprintf("http://%s/lineup.json", viper.GetString("web.base-address")), + } +} From 35ba398bcebf18c3e2ba831a8695e20fdf9f2256 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 15 Aug 2018 17:03:40 -0700 Subject: [PATCH 007/182] Checkpoint again. Too much to list, all good things --- .gitignore | 1 + Gopkg.lock | 129 ++-- Gopkg.toml | 8 - internal/go-gin-prometheus/middleware.go | 402 ++++++++++++ {m3u => internal/m3uplus}/main.go | 7 +- internal/providers/custom.go | 89 +++ {providers => internal/providers}/eternal.go | 4 +- .../providers}/hellraiser.go | 2 +- internal/providers/iptv-epg.go | 92 +++ internal/providers/iris.go | 4 + internal/providers/main.go | 97 +++ {providers => internal/providers}/tnt.go | 2 +- internal/providers/vaders.go | 133 ++++ {xmltv => internal/xmltv}/xmltv.dtd | 0 {xmltv => internal/xmltv}/xmltv.go | 8 +- {xmltv => internal/xmltv}/xmltv_test.go | 4 +- lineup.go | 609 ++++++++---------- main.go | 112 +++- providers/iptv-epg.go | 4 - providers/main.go | 97 --- providers/vaders.go | 72 --- routes.go | 89 ++- structs.go | 69 +- utils.go | 16 +- 24 files changed, 1350 insertions(+), 700 deletions(-) create mode 100644 internal/go-gin-prometheus/middleware.go rename {m3u => internal/m3uplus}/main.go (96%) create mode 100644 internal/providers/custom.go rename {providers => internal/providers}/eternal.go (64%) rename {providers => internal/providers}/hellraiser.go (79%) create mode 100644 internal/providers/iptv-epg.go create mode 100644 internal/providers/iris.go create mode 100644 internal/providers/main.go rename {providers => internal/providers}/tnt.go (83%) create mode 100644 internal/providers/vaders.go rename {xmltv => internal/xmltv}/xmltv.dtd (100%) rename {xmltv => internal/xmltv}/xmltv.go (99%) rename {xmltv => internal/xmltv}/xmltv_test.go (94%) delete mode 100644 providers/iptv-epg.go delete mode 100644 providers/main.go delete mode 100644 providers/vaders.go diff --git a/.gitignore b/.gitignore index a22990c..05fc00e 100644 --- a/.gitignore +++ b/.gitignore @@ -10,3 +10,4 @@ vendor/ /.release /.tarballs *.tar.gz +telly.config.* diff --git a/Gopkg.lock b/Gopkg.lock index cc87f39..3209f48 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -1,25 +1,6 @@ # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. -[[projects]] - branch = "master" - digest = "1:315c5f2f60c76d89b871c73f9bd5fe689cad96597afd50fb9992228ef80bdd34" - name = "github.com/alecthomas/template" - packages = [ - ".", - "parse", - ] - pruneopts = "UT" - revision = "a0175ee3bccc567396460bf5acd36800cb10c49c" - -[[projects]] - branch = "master" - digest = "1:c198fdc381e898e8fb62b8eb62758195091c313ad18e52a3067366e1dda2fb3c" - name = "github.com/alecthomas/units" - packages = ["."] - pruneopts = "UT" - revision = "2efee857e7cfd4f3d0138cc3cbb1b4966962b93a" - [[projects]] branch = "master" digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d" @@ -28,6 +9,14 @@ pruneopts = "UT" revision = "3a771d992973f24aa725d07868b467d1ddfceafb" +[[projects]] + digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd" + name = "github.com/fsnotify/fsnotify" + packages = ["."] + pruneopts = "UT" + revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9" + version = "v1.4.7" + [[projects]] branch = "master" digest = "1:36fe9527deed01d2a317617e59304eb2c4ce9f8a24115bcc5c2e37b3aee5bae4" @@ -56,6 +45,25 @@ revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265" version = "v1.1.0" +[[projects]] + branch = "master" + digest = "1:a361611b8c8c75a1091f00027767f7779b29cb37c456a71b8f2604c88057ab40" + name = "github.com/hashicorp/hcl" + packages = [ + ".", + "hcl/ast", + "hcl/parser", + "hcl/printer", + "hcl/scanner", + "hcl/strconv", + "hcl/token", + "json/parser", + "json/scanner", + "json/token", + ] + pruneopts = "UT" + revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168" + [[projects]] branch = "master" digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" @@ -80,6 +88,14 @@ revision = "e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f" version = "v0.1.0" +[[projects]] + digest = "1:c568d7727aa262c32bdf8a3f7db83614f7af0ed661474b24588de635c20024c7" + name = "github.com/magiconair/properties" + packages = ["."] + pruneopts = "UT" + revision = "c2353362d570a7bfa228149c62842019201cfb71" + version = "v1.8.0" + [[projects]] digest = "1:fa610f9fe6a93f4a75e64c83673dfff9bf1a34bbb21e6102021b6bc7850834a3" name = "github.com/mattn/go-isatty" @@ -103,6 +119,14 @@ pruneopts = "UT" revision = "f15292f7a699fcc1a38a80977f80a046874ba8ac" +[[projects]] + digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e" + name = "github.com/pelletier/go-toml" + packages = ["."] + pruneopts = "UT" + revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194" + version = "v1.2.0" + [[projects]] digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" name = "github.com/prometheus/client_golang" @@ -157,19 +181,54 @@ version = "v1.0.6" [[projects]] - digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" - name = "github.com/ugorji/go" - packages = ["codec"] + digest = "1:bd1ae00087d17c5a748660b8e89e1043e1e5479d0fea743352cda2f8dd8c4f84" + name = "github.com/spf13/afero" + packages = [ + ".", + "mem", + ] pruneopts = "UT" - revision = "c88ee250d0221a57af388746f5cf03768c21d6e2" + revision = "787d034dfe70e44075ccc060d346146ef53270ad" + version = "v1.1.1" + +[[projects]] + digest = "1:516e71bed754268937f57d4ecb190e01958452336fa73dbac880894164e91c1f" + name = "github.com/spf13/cast" + packages = ["."] + pruneopts = "UT" + revision = "8965335b8c7107321228e3e3702cab9832751bac" + version = "v1.2.0" [[projects]] branch = "master" - digest = "1:7e4543a28ce437be9d263089699c5fd6cefc0f02a63592f7f85c0c4e21245e0a" - name = "github.com/zsais/go-gin-prometheus" + digest = "1:8a020f916b23ff574845789daee6818daf8d25a4852419aae3f0b12378ba432a" + name = "github.com/spf13/jwalterweatherman" + packages = ["."] + pruneopts = "UT" + revision = "14d3d4c518341bea657dd8a226f5121c0ff8c9f2" + +[[projects]] + digest = "1:dab83a1bbc7ad3d7a6ba1a1cc1760f25ac38cdf7d96a5cdd55cd915a4f5ceaf9" + name = "github.com/spf13/pflag" packages = ["."] pruneopts = "UT" - revision = "3f93884fa240fd102425d65ce9781e561ba40496" + revision = "9a97c102cda95a86cec2345a6f09f55a939babf5" + version = "v1.0.2" + +[[projects]] + digest = "1:4fc8a61287ccfb4286e1ca5ad2ce3b0b301d746053bf44ac38cf34e40ae10372" + name = "github.com/spf13/viper" + packages = ["."] + pruneopts = "UT" + revision = "907c19d40d9a6c9bb55f040ff4ae45271a4754b9" + version = "v1.1.0" + +[[projects]] + digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" + name = "github.com/ugorji/go" + packages = ["codec"] + pruneopts = "UT" + revision = "c88ee250d0221a57af388746f5cf03768c21d6e2" [[projects]] branch = "master" @@ -207,7 +266,7 @@ revision = "98c5dad5d1a0e8a73845ecc8897d0bd56586511d" [[projects]] - digest = "1:aa4d6967a3237f8367b6bf91503964a77183ecf696f1273e8ad3551bb4412b5f" + digest = "1:4392fcf42d5cf0e3ff78c96b2acf8223d49e4fdc53eb77c99d2f8dfe4680e006" name = "golang.org/x/text" packages = [ "encoding", @@ -222,24 +281,19 @@ "encoding/unicode", "internal/gen", "internal/tag", + "internal/triegen", + "internal/ucd", "internal/utf8internal", "language", "runes", "transform", "unicode/cldr", + "unicode/norm", ] pruneopts = "UT" revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" version = "v0.3.0" -[[projects]] - digest = "1:c06d9e11d955af78ac3bbb26bd02e01d2f61f689e1a3bce2ef6fb683ef8a7f2d" - name = "gopkg.in/alecthomas/kingpin.v2" - packages = ["."] - pruneopts = "UT" - revision = "947dcec5ba9c011838740e680966fd7087a71d0d" - version = "v2.2.6" - [[projects]] digest = "1:1b4724d3c8125f6044925f02b485b74bfec9905cbf579d95aafd1a6c8f8447d3" name = "gopkg.in/go-playground/validator.v8" @@ -264,11 +318,12 @@ "github.com/kr/pretty", "github.com/mitchellh/mapstructure", "github.com/prometheus/client_golang/prometheus", + "github.com/prometheus/client_golang/prometheus/promhttp", "github.com/prometheus/common/version", "github.com/sirupsen/logrus", - "github.com/zsais/go-gin-prometheus", + "github.com/spf13/pflag", + "github.com/spf13/viper", "golang.org/x/net/html/charset", - "gopkg.in/alecthomas/kingpin.v2", ] solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index 31ebde3..546090b 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -49,14 +49,6 @@ name = "github.com/sirupsen/logrus" version = "1.0.6" -[[constraint]] - branch = "master" - name = "github.com/zsais/go-gin-prometheus" - -[[constraint]] - name = "gopkg.in/alecthomas/kingpin.v2" - version = "2.2.6" - [prune] go-tests = true unused-packages = true diff --git a/internal/go-gin-prometheus/middleware.go b/internal/go-gin-prometheus/middleware.go new file mode 100644 index 0000000..f3d7477 --- /dev/null +++ b/internal/go-gin-prometheus/middleware.go @@ -0,0 +1,402 @@ +// Package ginprometheus provides a Logrus logger for Gin requests. Slightly modified to remove spammy logs. +// For more info see https://github.com/zsais/go-gin-prometheus/pull/22. +package ginprometheus + +import ( + "bytes" + "io/ioutil" + "net/http" + "os" + "strconv" + "time" + + "github.com/gin-gonic/gin" + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/client_golang/prometheus/promhttp" + log "github.com/sirupsen/logrus" +) + +var defaultMetricPath = "/metrics" + +// Standard default metrics +// counter, counter_vec, gauge, gauge_vec, +// histogram, histogram_vec, summary, summary_vec +var reqCnt = &Metric{ + ID: "reqCnt", + Name: "requests_total", + Description: "How many HTTP requests processed, partitioned by status code and HTTP method.", + Type: "counter_vec", + Args: []string{"code", "method", "handler", "host", "url"}} + +var reqDur = &Metric{ + ID: "reqDur", + Name: "request_duration_seconds", + Description: "The HTTP request latencies in seconds.", + Type: "summary"} + +var resSz = &Metric{ + ID: "resSz", + Name: "response_size_bytes", + Description: "The HTTP response sizes in bytes.", + Type: "summary"} + +var reqSz = &Metric{ + ID: "reqSz", + Name: "request_size_bytes", + Description: "The HTTP request sizes in bytes.", + Type: "summary"} + +var standardMetrics = []*Metric{ + reqCnt, + reqDur, + resSz, + reqSz, +} + +/* +RequestCounterURLLabelMappingFn is a function which can be supplied to the middleware to control +the cardinality of the request counter's "url" label, which might be required in some contexts. +For instance, if for a "/customer/:name" route you don't want to generate a time series for every +possible customer name, you could use this function: +func(c *gin.Context) string { + url := c.Request.URL.String() + for _, p := range c.Params { + if p.Key == "name" { + url = strings.Replace(url, p.Value, ":name", 1) + break + } + } + return url +} +which would map "/customer/alice" and "/customer/bob" to their template "/customer/:name". +*/ +type RequestCounterURLLabelMappingFn func(c *gin.Context) string + +// Metric is a definition for the name, description, type, ID, and +// prometheus.Collector type (i.e. CounterVec, Summary, etc) of each metric +type Metric struct { + MetricCollector prometheus.Collector + ID string + Name string + Description string + Type string + Args []string +} + +// Prometheus contains the metrics gathered by the instance and its path +type Prometheus struct { + reqCnt *prometheus.CounterVec + reqDur, reqSz, resSz prometheus.Summary + router *gin.Engine + listenAddress string + Ppg PrometheusPushGateway + + MetricsList []*Metric + MetricsPath string + + ReqCntURLLabelMappingFn RequestCounterURLLabelMappingFn +} + +// PrometheusPushGateway contains the configuration for pushing to a Prometheus pushgateway (optional) +type PrometheusPushGateway struct { + + // Push interval in seconds + PushIntervalSeconds time.Duration + + // Push Gateway URL in format http://domain:port + // where JOBNAME can be any string of your choice + PushGatewayURL string + + // Local metrics URL where metrics are fetched from, this could be ommited in the future + // if implemented using prometheus common/expfmt instead + MetricsURL string + + // pushgateway job name, defaults to "gin" + Job string +} + +// NewPrometheus generates a new set of metrics with a certain subsystem name +func NewPrometheus(subsystem string, customMetricsList ...[]*Metric) *Prometheus { + + var metricsList []*Metric + + if len(customMetricsList) > 1 { + panic("Too many args. NewPrometheus( string, ).") + } else if len(customMetricsList) == 1 { + metricsList = customMetricsList[0] + } + + for _, metric := range standardMetrics { + metricsList = append(metricsList, metric) + } + + p := &Prometheus{ + MetricsList: metricsList, + MetricsPath: defaultMetricPath, + ReqCntURLLabelMappingFn: func(c *gin.Context) string { + return c.Request.URL.String() // i.e. by default do nothing, i.e. return URL as is + }, + } + + p.registerMetrics(subsystem) + + return p +} + +// SetPushGateway sends metrics to a remote pushgateway exposed on pushGatewayURL +// every pushIntervalSeconds. Metrics are fetched from metricsURL +func (p *Prometheus) SetPushGateway(pushGatewayURL, metricsURL string, pushIntervalSeconds time.Duration) { + p.Ppg.PushGatewayURL = pushGatewayURL + p.Ppg.MetricsURL = metricsURL + p.Ppg.PushIntervalSeconds = pushIntervalSeconds + p.startPushTicker() +} + +// SetPushGatewayJob job name, defaults to "gin" +func (p *Prometheus) SetPushGatewayJob(j string) { + p.Ppg.Job = j +} + +// SetListenAddress for exposing metrics on address. If not set, it will be exposed at the +// same address of the gin engine that is being used +func (p *Prometheus) SetListenAddress(address string) { + p.listenAddress = address + if p.listenAddress != "" { + p.router = gin.Default() + } +} + +// SetListenAddressWithRouter for using a separate router to expose metrics. (this keeps things like GET /metrics out of +// your content's access log). +func (p *Prometheus) SetListenAddressWithRouter(listenAddress string, r *gin.Engine) { + p.listenAddress = listenAddress + if len(p.listenAddress) > 0 { + p.router = r + } +} + +func (p *Prometheus) setMetricsPath(e *gin.Engine) { + + if p.listenAddress != "" { + p.router.GET(p.MetricsPath, prometheusHandler()) + p.runServer() + } else { + e.GET(p.MetricsPath, prometheusHandler()) + } +} + +func (p *Prometheus) setMetricsPathWithAuth(e *gin.Engine, accounts gin.Accounts) { + + if p.listenAddress != "" { + p.router.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler()) + p.runServer() + } else { + e.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler()) + } + +} + +func (p *Prometheus) runServer() { + if p.listenAddress != "" { + go p.router.Run(p.listenAddress) + } +} + +func (p *Prometheus) getMetrics() []byte { + response, _ := http.Get(p.Ppg.MetricsURL) + + defer response.Body.Close() + body, _ := ioutil.ReadAll(response.Body) + + return body +} + +func (p *Prometheus) getPushGatewayURL() string { + h, _ := os.Hostname() + if p.Ppg.Job == "" { + p.Ppg.Job = "gin" + } + return p.Ppg.PushGatewayURL + "/metrics/job/" + p.Ppg.Job + "/instance/" + h +} + +func (p *Prometheus) sendMetricsToPushGateway(metrics []byte) { + req, err := http.NewRequest("POST", p.getPushGatewayURL(), bytes.NewBuffer(metrics)) + client := &http.Client{} + if _, err = client.Do(req); err != nil { + log.WithError(err).Errorln("Error sending to push gateway") + } +} + +func (p *Prometheus) startPushTicker() { + ticker := time.NewTicker(time.Second * p.Ppg.PushIntervalSeconds) + go func() { + for range ticker.C { + p.sendMetricsToPushGateway(p.getMetrics()) + } + }() +} + +// NewMetric associates prometheus.Collector based on Metric.Type +func NewMetric(m *Metric, subsystem string) prometheus.Collector { + var metric prometheus.Collector + switch m.Type { + case "counter_vec": + metric = prometheus.NewCounterVec( + prometheus.CounterOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + m.Args, + ) + case "counter": + metric = prometheus.NewCounter( + prometheus.CounterOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + ) + case "gauge_vec": + metric = prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + m.Args, + ) + case "gauge": + metric = prometheus.NewGauge( + prometheus.GaugeOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + ) + case "histogram_vec": + metric = prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + m.Args, + ) + case "histogram": + metric = prometheus.NewHistogram( + prometheus.HistogramOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + ) + case "summary_vec": + metric = prometheus.NewSummaryVec( + prometheus.SummaryOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + m.Args, + ) + case "summary": + metric = prometheus.NewSummary( + prometheus.SummaryOpts{ + Subsystem: subsystem, + Name: m.Name, + Help: m.Description, + }, + ) + } + return metric +} + +func (p *Prometheus) registerMetrics(subsystem string) { + + for _, metricDef := range p.MetricsList { + metric := NewMetric(metricDef, subsystem) + if err := prometheus.Register(metric); err != nil { + log.WithError(err).Errorf("%s could not be registered in Prometheus", metricDef.Name) + } + switch metricDef { + case reqCnt: + p.reqCnt = metric.(*prometheus.CounterVec) + case reqDur: + p.reqDur = metric.(prometheus.Summary) + case resSz: + p.resSz = metric.(prometheus.Summary) + case reqSz: + p.reqSz = metric.(prometheus.Summary) + } + metricDef.MetricCollector = metric + } +} + +// Use adds the middleware to a gin engine. +func (p *Prometheus) Use(e *gin.Engine) { + e.Use(p.handlerFunc()) + p.setMetricsPath(e) +} + +// UseWithAuth adds the middleware to a gin engine with BasicAuth. +func (p *Prometheus) UseWithAuth(e *gin.Engine, accounts gin.Accounts) { + e.Use(p.handlerFunc()) + p.setMetricsPathWithAuth(e, accounts) +} + +func (p *Prometheus) handlerFunc() gin.HandlerFunc { + return func(c *gin.Context) { + if c.Request.URL.String() == p.MetricsPath { + c.Next() + return + } + + start := time.Now() + reqSz := computeApproximateRequestSize(c.Request) + + c.Next() + + status := strconv.Itoa(c.Writer.Status()) + elapsed := float64(time.Since(start)) / float64(time.Second) + resSz := float64(c.Writer.Size()) + + p.reqDur.Observe(elapsed) + url := p.ReqCntURLLabelMappingFn(c) + p.reqCnt.WithLabelValues(status, c.Request.Method, c.HandlerName(), c.Request.Host, url).Inc() + p.reqSz.Observe(float64(reqSz)) + p.resSz.Observe(resSz) + } +} + +func prometheusHandler() gin.HandlerFunc { + h := promhttp.Handler() + return func(c *gin.Context) { + h.ServeHTTP(c.Writer, c.Request) + } +} + +// From https://github.com/DanielHeckrath/gin-prometheus/blob/master/gin_prometheus.go +func computeApproximateRequestSize(r *http.Request) int { + s := 0 + if r.URL != nil { + s = len(r.URL.String()) + } + + s += len(r.Method) + s += len(r.Proto) + for name, values := range r.Header { + s += len(name) + for _, value := range values { + s += len(value) + } + } + s += len(r.Host) + + // N.B. r.Form and r.MultipartForm are assumed to be included in r.URL. + + if r.ContentLength != -1 { + s += int(r.ContentLength) + } + return s +} diff --git a/m3u/main.go b/internal/m3uplus/main.go similarity index 96% rename from m3u/main.go rename to internal/m3uplus/main.go index 5aa449f..43d2606 100644 --- a/m3u/main.go +++ b/internal/m3uplus/main.go @@ -1,4 +1,5 @@ -package m3u +// Package m3uplus provides a M3U Plus parser. +package m3uplus import ( "bytes" @@ -13,7 +14,7 @@ import ( // Playlist is a type that represents an m3u playlist containing 0 or more tracks type Playlist struct { - Tracks []*Track + Tracks []Track } // Track represents an m3u track @@ -86,7 +87,7 @@ func decodeLine(playlist *Playlist, line string, lineNumber int) error { switch { case strings.HasPrefix(line, "#EXTINF:"): - track := &Track{ + track := Track{ Raw: line, LineNumber: lineNumber, } diff --git a/internal/providers/custom.go b/internal/providers/custom.go new file mode 100644 index 0000000..e6a93c0 --- /dev/null +++ b/internal/providers/custom.go @@ -0,0 +1,89 @@ +package providers + +import ( + "strconv" + "strings" + + m3u "github.com/tombowditch/telly/internal/m3uplus" + "github.com/tombowditch/telly/internal/xmltv" +) + +type customProvider struct { + BaseConfig Configuration +} + +func newCustomProvider(config *Configuration) (Provider, error) { + return &customProvider{*config}, nil +} + +func (i *customProvider) Name() string { + return i.BaseConfig.Name +} + +func (i *customProvider) PlaylistURL() string { + return i.BaseConfig.M3U +} + +func (i *customProvider) EPGURL() string { + return i.BaseConfig.EPG +} + +// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. +func (i *customProvider) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { + channelVal := track.Tags["tvg-chno"] + if i.BaseConfig.ChannelNumberKey != "" { + channelVal = track.Tags[i.BaseConfig.ChannelNumberKey] + } + + chanNum := 0 + + if channelNumber, channelNumberErr := strconv.Atoi(channelVal); channelNumberErr == nil { + chanNum = channelNumber + } + + nameVal := track.Name + if i.BaseConfig.NameKey != "" { + nameVal = track.Tags[i.BaseConfig.NameKey] + } + + logoVal := track.Tags["tvg-logo"] + if i.BaseConfig.LogoKey != "" { + logoVal = track.Tags[i.BaseConfig.LogoKey] + } + + pChannel := &ProviderChannel{ + Name: nameVal, + Logo: logoVal, + Number: chanNum, + StreamURL: track.URI, + StreamID: chanNum, + HD: strings.Contains(strings.ToLower(track.Name), "hd"), + StreamFormat: "Unknown", + Track: track, + OnDemand: false, + } + + epgVal := track.Tags["tvg-id"] + if i.BaseConfig.EPGMatchKey != "" { + epgVal = track.Tags[i.BaseConfig.EPGMatchKey] + } + + if xmlChan, ok := channelMap[epgVal]; ok { + pChannel.EPGMatch = epgVal + pChannel.EPGChannel = &xmlChan + } + + return pChannel, nil +} + +func (i *customProvider) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { + return &programme +} + +func (i *customProvider) Configuration() Configuration { + return i.BaseConfig +} + +func (i *customProvider) RegexKey() string { + return i.BaseConfig.FilterKey +} diff --git a/providers/eternal.go b/internal/providers/eternal.go similarity index 64% rename from providers/eternal.go rename to internal/providers/eternal.go index fc59a4f..72bc1b6 100644 --- a/providers/eternal.go +++ b/internal/providers/eternal.go @@ -1,4 +1,4 @@ package providers -// M3U:http://live.eternaltv.net:25461/get.php?username=xxxxxxx&password=xxxxxx&output=ts&type=m3u_plus -// XMLTV: http://live.eternaltv.net:25461/xmltv.php?username=xxxxx&password=xxxxx&type=m3u_plus&output=ts +// M3U:http://live.eternaltv.net:25461/get.php?username=xxxxxxx&password=xxxxxx&output=ts&type=m3uplus +// XMLTV: http://live.eternaltv.net:25461/xmltv.php?username=xxxxx&password=xxxxx&type=m3uplus&output=ts diff --git a/providers/hellraiser.go b/internal/providers/hellraiser.go similarity index 79% rename from providers/hellraiser.go rename to internal/providers/hellraiser.go index de264a8..0608474 100644 --- a/providers/hellraiser.go +++ b/internal/providers/hellraiser.go @@ -1,4 +1,4 @@ package providers -// Playlist URL: http://liquidit.info:8080/get.php?username=xxxx&password=xxxxxxx&type=m3u_plus&output=ts +// Playlist URL: http://liquidit.info:8080/get.php?username=xxxx&password=xxxxxxx&type=m3uplus&output=ts // XMLTV URL: http://liquidit.info:8080/xmltv.php?username=xxxxxx&password=xxxxxx diff --git a/internal/providers/iptv-epg.go b/internal/providers/iptv-epg.go new file mode 100644 index 0000000..63c5602 --- /dev/null +++ b/internal/providers/iptv-epg.go @@ -0,0 +1,92 @@ +package providers + +import ( + "fmt" + "strconv" + "strings" + + m3u "github.com/tombowditch/telly/internal/m3uplus" + "github.com/tombowditch/telly/internal/xmltv" +) + +// M3U: http://iptv-epg.com/.m3u +// XMLTV: http://iptv-epg.com/.xml + +type iptvepg struct { + BaseConfig Configuration +} + +func newIPTVEPG(config *Configuration) (Provider, error) { + return &iptvepg{*config}, nil +} + +func (i *iptvepg) Name() string { + return "IPTV-EPG" +} + +func (i *iptvepg) PlaylistURL() string { + return fmt.Sprintf("http://iptv-epg.com/%s.m3u", i.BaseConfig.Username) +} + +func (i *iptvepg) EPGURL() string { + return fmt.Sprintf("http://iptv-epg.com/%s.xml", i.BaseConfig.Password) +} + +// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. +func (i *iptvepg) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { + channelVal := track.Tags["tvg-chno"] + if i.BaseConfig.ChannelNumberKey != "" { + channelVal = track.Tags[i.BaseConfig.ChannelNumberKey] + } + + channelNumber, channelNumberErr := strconv.Atoi(channelVal) + if channelNumberErr != nil { + return nil, channelNumberErr + } + + nameVal := track.Name + if i.BaseConfig.NameKey != "" { + nameVal = track.Tags[i.BaseConfig.NameKey] + } + + logoVal := track.Tags["tvg-logo"] + if i.BaseConfig.LogoKey != "" { + logoVal = track.Tags[i.BaseConfig.LogoKey] + } + + pChannel := &ProviderChannel{ + Name: nameVal, + Logo: logoVal, + Number: channelNumber, + StreamURL: track.URI, + StreamID: channelNumber, + HD: strings.Contains(strings.ToLower(track.Name), "hd"), + StreamFormat: "Unknown", + Track: track, + OnDemand: false, + } + + epgVal := track.Tags["tvg-id"] + if i.BaseConfig.EPGMatchKey != "" { + epgVal = track.Tags[i.BaseConfig.EPGMatchKey] + } + + if xmlChan, ok := channelMap[epgVal]; ok { + pChannel.EPGMatch = epgVal + pChannel.EPGChannel = &xmlChan + } + + return pChannel, nil +} + +func (i *iptvepg) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { + return &programme +} + +func (i *iptvepg) Configuration() Configuration { + return i.BaseConfig +} + +func (i *iptvepg) RegexKey() string { + return "group-title" +} diff --git a/internal/providers/iris.go b/internal/providers/iris.go new file mode 100644 index 0000000..01d10ec --- /dev/null +++ b/internal/providers/iris.go @@ -0,0 +1,4 @@ +package providers + +// http://irislinks.net:83/get.php?username=username&password=password&type=m3uplus&output=ts +// http://irislinks.net:83/xmltv.php?username=username&password=password diff --git a/internal/providers/main.go b/internal/providers/main.go new file mode 100644 index 0000000..f772532 --- /dev/null +++ b/internal/providers/main.go @@ -0,0 +1,97 @@ +package providers + +import ( + "regexp" + "strings" + + m3u "github.com/tombowditch/telly/internal/m3uplus" + "github.com/tombowditch/telly/internal/xmltv" +) + +var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch +var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString +var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString +var hdRegex = regexp.MustCompile(`hd|4k`) + +type Configuration struct { + Name string `json:"-"` + Provider string + + Username string `json:"username"` + Password string `json:"password"` + + M3U string `json:"-"` + EPG string `json:"-"` + + VideoOnDemand bool `json:"-"` + + Filter string + FilterKey string + FilterRaw bool + + SortKey string + SortReverse bool + + Favorites []string + FavoriteTag string + + CacheFiles bool + + NameKey string + LogoKey string + ChannelNumberKey string + EPGMatchKey string +} + +func (i *Configuration) GetProvider() (Provider, error) { + switch strings.ToLower(i.Provider) { + case "vaders": + return newVaders(i) + case "iptv-epg", "iptvepg": + return newIPTVEPG(i) + default: + return newCustomProvider(i) + } +} + +// ProviderChannel describes a channel available in the providers lineup with necessary pieces parsed into fields. +type ProviderChannel struct { + Name string + StreamID int // Should be the integer just before .ts. + Number int + Logo string + StreamURL string + HD bool + Quality string + OnDemand bool + StreamFormat string + Favorite bool + + EPGMatch string + EPGChannel *xmltv.Channel + EPGProgrammes []xmltv.Programme + Track m3u.Track +} + +// Provider describes a IPTV provider configuration. +type Provider interface { + Name() string + PlaylistURL() string + EPGURL() string + + // These are functions to extract information from playlists. + ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) + ProcessProgramme(programme xmltv.Programme) *xmltv.Programme + + RegexKey() string + Configuration() Configuration +} + +func contains(s []string, e string) bool { + for _, ss := range s { + if e == ss { + return true + } + } + return false +} diff --git a/providers/tnt.go b/internal/providers/tnt.go similarity index 83% rename from providers/tnt.go rename to internal/providers/tnt.go index 2f8295f..3960706 100644 --- a/providers/tnt.go +++ b/internal/providers/tnt.go @@ -1,4 +1,4 @@ package providers -// M3U: http://thesepeanutz.xyz:2052/get.php?username=xxx&password=xxx&type=m3u_plus&output=ts +// M3U: http://thesepeanutz.xyz:2052/get.php?username=xxx&password=xxx&type=m3uplus&output=ts // XMLTV: http://thesepeanutz.xyz:2052/xmltv.php?username=xxx&password=xxx diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go new file mode 100644 index 0000000..bcb2fa6 --- /dev/null +++ b/internal/providers/vaders.go @@ -0,0 +1,133 @@ +package providers + +import ( + "encoding/base64" + "encoding/json" + "fmt" + "regexp" + "strconv" + "strings" + + log "github.com/sirupsen/logrus" + m3u "github.com/tombowditch/telly/internal/m3uplus" + "github.com/tombowditch/telly/internal/xmltv" +) + +// This regex matches and extracts the following URLs. +// http://vapi.vaders.tv/play/dvr/${start}/123.ts?duration=3600&token= +// http://vapi.vaders.tv/play/123.ts?token= +// http://vapi.vaders.tv/play/vod/123.mp4.m3u8?token= +// http://vapi.vaders.tv/play/vod/123.avi.m3u8?token= +// http://vapi.vaders.tv/play/vod/123.mkv.m3u8?token= +var vadersURL = regexp.MustCompile(`/(vod/|dvr/\${start}/)?(\d+).(ts|.*.m3u8)\?(duration=\d+&)?token=`).FindAllStringSubmatch + +// M3U: http://api.vaders.tv/vget?username=xxx&password=xxx&format=ts +// XMLTV: http://vaders.tv/p2.xml + +type vader struct { + BaseConfig Configuration + + Token string `json:"-"` +} + +func newVaders(config *Configuration) (Provider, error) { + tok, tokErr := json.Marshal(config) + if tokErr != nil { + return nil, tokErr + } + + return &vader{*config, base64.StdEncoding.EncodeToString(tok)}, nil +} + +func (v *vader) Name() string { + return "Vaders.tv" +} + +func (v *vader) PlaylistURL() string { + return fmt.Sprintf("http://api.vaders.tv/vget?username=%s&password=%s&vod=%t&format=ts", v.BaseConfig.Username, v.BaseConfig.Password, v.BaseConfig.VideoOnDemand) +} + +func (v *vader) EPGURL() string { + return "http://vaders.tv/p2.xml.gz" +} + +// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. +func (v *vader) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { + streamURL := vadersURL(track.URI, -1)[0] + + vod := strings.Contains(streamURL[1], "vod") + + if v.BaseConfig.VideoOnDemand == false && vod { + return nil, nil + } + + channelID, channelIDErr := strconv.Atoi(streamURL[2]) + if channelIDErr != nil { + return nil, channelIDErr + } + + nameVal := track.Tags["tvg-name"] + if v.BaseConfig.NameKey != "" { + nameVal = track.Tags[v.BaseConfig.NameKey] + } + + logoVal := track.Tags["tvg-logo"] + if v.BaseConfig.LogoKey != "" { + logoVal = track.Tags[v.BaseConfig.LogoKey] + } + + pChannel := &ProviderChannel{ + Name: nameVal, + Logo: logoVal, + StreamURL: track.URI, + StreamID: channelID, + HD: strings.Contains(strings.ToLower(track.Tags["tvg-name"]), "hd"), + StreamFormat: streamURL[3], + Track: track, + OnDemand: vod, + } + + if xmlChan, ok := channelMap[track.Tags["tvg-id"]]; ok { + pChannel.EPGMatch = track.Tags["tvg-id"] + pChannel.EPGChannel = &xmlChan + + for _, displayName := range xmlChan.DisplayNames { + if channelNumberRegex(displayName.Value) { + if chanNum, chanNumErr := strconv.Atoi(displayName.Value); chanNumErr == nil { + pChannel.Number = chanNum + } + } + } + } + + favoriteTag := "tvg-id" + + if v.BaseConfig.FavoriteTag != "" { + favoriteTag = v.BaseConfig.FavoriteTag + } + + if _, ok := track.Tags[favoriteTag]; !ok { + log.Panicf("The specified favorite tag (%s) doesn't exist on the track with URL %s", favoriteTag, track.URI) + return nil, nil + } + + pChannel.Favorite = contains(v.BaseConfig.Favorites, track.Tags[favoriteTag]) + + return pChannel, nil +} + +func (v *vader) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { + for idx, title := range programme.Titles { + programme.Titles[idx].Value = strings.Replace(title.Value, " [New!]", "", -1) + } + + return &programme +} + +func (v *vader) Configuration() Configuration { + return v.BaseConfig +} + +func (v *vader) RegexKey() string { + return "group-title" +} diff --git a/xmltv/xmltv.dtd b/internal/xmltv/xmltv.dtd similarity index 100% rename from xmltv/xmltv.dtd rename to internal/xmltv/xmltv.dtd diff --git a/xmltv/xmltv.go b/internal/xmltv/xmltv.go similarity index 99% rename from xmltv/xmltv.go rename to internal/xmltv/xmltv.go index 911c275..5567f1f 100644 --- a/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -65,6 +65,10 @@ type Channel struct { Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` URLs []string `xml:"url,omitempty" json:"urls,omitempty" ` ID string `xml:"id,attr" json:"id,omitempty" ` + + // These fields are outside of the XMLTV spec. + // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. + LCN int `xml:"lcn" json:"lcn,omitempty"` } // Programme details of a single programme transmission @@ -102,10 +106,6 @@ type Programme struct { Videoplus string `xml:"videoplus,attr,omitempty" json:"videoplus,omitempty"` Channel string `xml:"channel,attr" json:"channel"` Clumpidx string `xml:"clumpidx,attr,omitempty" json:"clumpidx,omitempty"` - - // These fields are outside of the XMLTV spec. - // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. - LCN int `xml:"lcn,attr" json:"lcn,omitempty"` } // CommonElement element structure that is common, i.e. Italy diff --git a/xmltv/xmltv_test.go b/internal/xmltv/xmltv_test.go similarity index 94% rename from xmltv/xmltv_test.go rename to internal/xmltv/xmltv_test.go index 0cdc479..f2eec7c 100644 --- a/xmltv/xmltv_test.go +++ b/internal/xmltv/xmltv_test.go @@ -17,7 +17,7 @@ func dummyReader(charset string, input io.Reader) (io.Reader, error) { } func TestDecode(t *testing.T) { - // Example downloaded from http://wiki.xmltv.org/index.php/XMLTVFormat + // Example downloaded from http://wiki.xmltv.org/index.php/internal/xmltvFormat // One may check it with `xmllint --noout --dtdvalid xmltv.dtd example.xml` f, err := os.Open("example.xml") if err != nil { @@ -60,7 +60,7 @@ func TestDecode(t *testing.T) { }, Icons: []Icon{ Icon{ - Source: `file://C:\Perl\site/share/xmltv/icons/KERA.gif`, + Source: `file://C:\Perl\site/share/internal/xmltv/icons/KERA.gif`, }, }, } diff --git a/lineup.go b/lineup.go index 4b3badb..3881f7c 100644 --- a/lineup.go +++ b/lineup.go @@ -1,6 +1,7 @@ package main import ( + "compress/gzip" "encoding/xml" "fmt" "io" @@ -8,360 +9,303 @@ import ( "os" "regexp" "sort" - "strconv" "strings" - "time" "github.com/spf13/viper" - "github.com/tombowditch/telly/m3u" - "github.com/tombowditch/telly/providers" - "github.com/tombowditch/telly/xmltv" + m3u "github.com/tombowditch/telly/internal/m3uplus" + "github.com/tombowditch/telly/internal/providers" + "github.com/tombowditch/telly/internal/xmltv" ) -var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString -var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString -var hdRegex = regexp.MustCompile(`hd|4k`) - -// Track describes a single M3U segment. This struct includes m3u.Track as well as specific IPTV fields we want to get. -type Track struct { - *m3u.Track - SafeURI string `json:"URI"` - Catchup string `m3u:"catchup" json:",omitempty"` - CatchupDays string `m3u:"catchup-days" json:",omitempty"` - CatchupSource string `m3u:"catchup-source" json:",omitempty"` - GroupTitle string `m3u:"group-title" json:",omitempty"` - TvgID string `m3u:"tvg-id" json:",omitempty"` - TvgLogo string `m3u:"tvg-logo" json:",omitempty"` - TvgName string `m3u:"tvg-name" json:",omitempty"` - TvgChannelNumber string `m3u:"tvg-chno" json:",omitempty"` - ChannelID string `m3u:"channel-id" json:",omitempty"` - - XMLTVChannel *xmlTVChannel `json:",omitempty"` - XMLTVProgrammes *[]xmltv.Programme `json:",omitempty"` +// var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString +// var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString +// var hdRegex = regexp.MustCompile(`hd|4k`) + +// hdHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. +type hdHomeRunLineupItem struct { + XMLName xml.Name `xml:"Program" json:"-"` + + AudioCodec string `xml:",omitempty" json:",omitempty"` + DRM convertibleBoolean `xml:",omitempty" json:",string,omitempty"` + Favorite convertibleBoolean `xml:",omitempty" json:",string,omitempty"` + GuideName string `xml:",omitempty" json:",omitempty"` + GuideNumber int `xml:",omitempty" json:",string,omitempty"` + HD convertibleBoolean `xml:",omitempty" json:",string,omitempty"` + URL string `xml:",omitempty" json:",omitempty"` + VideoCodec string `xml:",omitempty" json:",omitempty"` + + provider providers.Provider + providerChannel providers.ProviderChannel } -func (t *Track) PrettyName() string { - if t.XMLTVChannel != nil { - return t.XMLTVChannel.LongName - } else if t.TvgName != "" { - return t.TvgName - } else if t.Track.Name != "" { - return t.Track.Name +func newHDHRItem(provider *providers.Provider, providerChannel *providers.ProviderChannel) hdHomeRunLineupItem { + return hdHomeRunLineupItem{ + DRM: convertibleBoolean(false), + GuideName: providerChannel.Name, + GuideNumber: providerChannel.Number, + Favorite: convertibleBoolean(providerChannel.Favorite), + HD: convertibleBoolean(providerChannel.HD), + URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), providerChannel.Number), + provider: *provider, + providerChannel: *providerChannel, } - - return t.Name -} - -// Playlist describes a single M3U playlist. -type Playlist struct { - *m3u.Playlist - *M3UFile - - Tracks []Track - Channels []HDHomeRunChannel - TracksCount int - FilteredTracksCount int - EPGProvided bool -} - -// Filter will filter the raw m3u.Playlist m3u.Track slice into the Track slice of the Playlist. -func (p *Playlist) Filter() error { - for _, oldTrack := range p.Playlist.Tracks { - track := Track{ - Track: oldTrack, - SafeURI: safeStringsRegex.ReplaceAllStringFunc(oldTrack.URI, stringSafer), - } - - if unmarshalErr := oldTrack.UnmarshalTags(&track); unmarshalErr != nil { - return unmarshalErr - } - - if GetStringAsRegex("filter.regexstr").MatchString(track.Raw) == viper.GetBool("filter.regexinclusive") { - p.Tracks = append(p.Tracks, track) - } - } - - return nil -} - -// M3UFile describes a path and transport to a M3U provided in the configuration. -type M3UFile struct { - Path string `json:"-"` - SafePath string `json:"Path"` - Transport string } -// HDHomeRunChannel is a HDHomeRun specification compatible representation of a Track available in the Lineup. -type HDHomeRunChannel struct { - AudioCodec string `json:",omitempty"` - DRM convertibleBoolean `json:",string,omitempty"` - Favorite convertibleBoolean `json:",string,omitempty"` - GuideName string `json:",omitempty"` - GuideNumber int `json:",string,omitempty"` - HD convertibleBoolean `json:",string,omitempty"` - URL string `json:",omitempty"` - VideoCodec string `json:",omitempty"` - - track *Track -} - -// Lineup is a collection of tracks -type Lineup struct { - Providers []providers.Provider - - Playlists []Playlist - PlaylistsCount int - TracksCount int - FilteredTracksCount int - - StartingChannelNumber int - channelNumber int +// lineup contains the state of the application. +type lineup struct { + Sources []providers.Provider - Refreshing bool - LastRefreshed time.Time `json:",omitempty"` + Scanning bool - xmlTvChannelMap map[string]xmlTVChannel - channelsInXMLTv []string - xmlTv xmltv.TV - xmlTvSourceInfoURL []string - xmlTvSourceInfoName []string - xmlTvSourceDataURL []string + // Stores the channel number for found channels without a number. + assignedChannelNumber int + // If true, use channel numbers found in EPG, if any, before assigning. xmlTVChannelNumbers bool - chanNumToURLMap map[string]string + channels map[int]hdHomeRunLineupItem } -// NewLineup returns a new Lineup for the given config struct. -func NewLineup() *Lineup { - tv := xmltv.TV{ - GeneratorInfoName: namespaceWithVersion, - GeneratorInfoURL: "https://github.com/tombowditch/telly", - } - - lineup := &Lineup{ - xmlTVChannelNumbers: viper.GetBool("iptv.xmltv-channels"), - chanNumToURLMap: make(map[string]string), - xmlTv: tv, - xmlTvChannelMap: make(map[string]xmlTVChannel), - StartingChannelNumber: viper.GetInt("iptv.starting-channel"), - channelNumber: viper.GetInt("iptv.starting-channel"), - Refreshing: false, - LastRefreshed: time.Now(), - } - +// newLineup returns a new lineup for the given config struct. +func newLineup() *lineup { var cfgs []providers.Configuration if unmarshalErr := viper.UnmarshalKey("source", &cfgs); unmarshalErr != nil { log.WithError(unmarshalErr).Panicln("Unable to unmarshal source configuration to slice of providers.Configuration, check your configuration!") } + if viper.IsSet("iptv.playlist") { + log.Warnln("Legacy --iptv.playlist argument or environment variable provided, using Custom provider with default configuration, this may fail! If so, you should use a configuration file for full flexibility.") + regexStr := ".*" + if viper.IsSet("filter.regex") { + regexStr = viper.GetString("filter.regex") + } + cfgs = append(cfgs, providers.Configuration{ + Name: "Legacy provider created using arguments/environment variables", + M3U: viper.GetString("iptv.playlist"), + Provider: "custom", + Filter: regexStr, + FilterRaw: true, + }) + } + + lineup := &lineup{ + assignedChannelNumber: viper.GetInt("iptv.starting-channel"), + xmlTVChannelNumbers: viper.GetBool("iptv.xmltv-channels"), + channels: make(map[int]hdHomeRunLineupItem), + } + for _, cfg := range cfgs { - log.Infoln("Adding provider", cfg.Name) provider, providerErr := cfg.GetProvider() if providerErr != nil { panic(providerErr) } - if addErr := lineup.AddProvider(provider); addErr != nil { - log.WithError(addErr).Panicln("error adding new provider to lineup") - } + + lineup.Sources = append(lineup.Sources, provider) } return lineup } -// AddProvider adds a new Provider to the Lineup. -func (l *Lineup) AddProvider(provider providers.Provider) error { - reader, info, readErr := l.getM3U(provider.PlaylistURL()) - if readErr != nil { - log.WithError(readErr).Errorln("error getting m3u") - return readErr - } - - rawPlaylist, err := m3u.Decode(reader) - if err != nil { - log.WithError(err).Errorln("unable to parse m3u file") - return err - } +// Scan processes all sources. +func (l *lineup) Scan() error { - if provider.EPGURL() != "" { - epg, epgReadErr := l.getXMLTV(provider.EPGURL()) - if epgReadErr != nil { - log.WithError(epgReadErr).Errorln("error getting XMLTV") - return epgReadErr - } + l.Scanning = true - chanMap, chanMapErr := l.processXMLTV(epg) - if chanMapErr != nil { - log.WithError(chanMapErr).Errorln("Error building channel mapping") - } + totalAddedChannels := 0 - for chanID, chann := range chanMap { - l.xmlTvChannelMap[chanID] = chann + for _, provider := range l.Sources { + addedChannels, providerErr := l.processProvider(provider) + if providerErr != nil { + log.WithError(providerErr).Errorln("error when processing provider") } + totalAddedChannels = totalAddedChannels + addedChannels } - playlist, playlistErr := l.NewPlaylist(provider, rawPlaylist, info) - if playlistErr != nil { - return playlistErr + if totalAddedChannels > 420 { + log.Panicf("telly has loaded more than 420 channels (%d) into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You must use regular expressions to filter out channels. You can also start another Telly instance.", totalAddedChannels) } - l.Playlists = append(l.Playlists, playlist) - l.PlaylistsCount = len(l.Playlists) - l.TracksCount = l.TracksCount + playlist.TracksCount - l.FilteredTracksCount = l.FilteredTracksCount + playlist.FilteredTracksCount + l.Scanning = false return nil } -// NewPlaylist will return a new and filtered Playlist for the given m3u.Playlist and M3UFile. -func (l *Lineup) NewPlaylist(provider providers.Provider, rawPlaylist *m3u.Playlist, info *M3UFile) (Playlist, error) { - hasEPG := provider.EPGURL() != "" - playlist := Playlist{rawPlaylist, info, nil, nil, len(rawPlaylist.Tracks), 0, hasEPG} +func (l *lineup) processProvider(provider providers.Provider) (int, error) { + addedChannels := 0 + m3u, channelMap, programmeMap, prepareErr := l.prepareProvider(provider) + if prepareErr != nil { + log.WithError(prepareErr).Errorln("error when preparing provider") + } - if filterErr := playlist.Filter(); filterErr != nil { - log.WithError(filterErr).Errorln("error during filtering of channels, check your regex and try again") - return playlist, filterErr + if provider.Configuration().SortKey != "" { + sortKey := provider.Configuration().SortKey + sort.Slice(m3u.Tracks, func(i, j int) bool { + if _, ok := m3u.Tracks[i].Tags[sortKey]; ok { + log.Panicf("the provided sort key (%s) doesn't exist in the M3U!", sortKey) + return false + } + ii := m3u.Tracks[i].Tags[sortKey] + jj := m3u.Tracks[j].Tags[sortKey] + if provider.Configuration().SortReverse { + return ii < jj + } + return ii > jj + }) } - for idx, track := range playlist.Tracks { - tt, channelNumber, hd, ttErr := l.processTrack(provider, track) - if ttErr != nil { - return playlist, ttErr + for _, track := range m3u.Tracks { + // First, we run the filter. + if !l.FilterTrack(provider, track) { + log.Debugf("Channel %s didn't pass the provider (%s) filter, skipping!", track.Name, provider.Name()) + return addedChannels, nil } - if hasEPG && tt.XMLTVChannel == nil { - log.Warnf("%s (#%d) is not being exposed to Plex because there was no EPG data found.", tt.Name, channelNumber) - continue + // Then we do the provider specific translation to a hdHomeRunLineupItem. + channel, channelErr := provider.ParseTrack(track, channelMap) + if channelErr != nil { + return addedChannels, channelErr } - playlist.Tracks[idx] = *tt - - guideName := tt.PrettyName() + channel, processErr := l.processProviderChannel(channel, programmeMap) + if processErr != nil { + log.WithError(processErr).Errorln("error processing track") + } else if channel == nil { + log.Infof("Channel %s was returned empty from the provider (%s)", track.Name, provider.Name()) + continue + } + addedChannels = addedChannels + 1 - log.Debugln("Assigning", channelNumber, l.channelNumber, "to", guideName) + l.channels[channel.Number] = newHDHRItem(&provider, channel) + } - hdhr := HDHomeRunChannel{ - GuideNumber: channelNumber, - GuideName: guideName, - URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), channelNumber), - HD: convertibleBoolean(hd), - DRM: convertibleBoolean(false), - } + log.Infof("Loaded %d channels into the lineup from %s", addedChannels, provider.Name()) - if !channelExists(playlist.Channels, hdhr) { - playlist.Channels = append(playlist.Channels, hdhr) - l.chanNumToURLMap[strconv.Itoa(channelNumber)] = tt.Track.URI - } + return addedChannels, nil +} - if channelNumber == l.channelNumber { // Only increment lineup channel number if its for a channel that didnt have a XMLTV entry. - l.channelNumber = l.channelNumber + 1 - } +func (l *lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { + cacheFiles := provider.Configuration().CacheFiles + reader, m3uErr := getM3U(provider.PlaylistURL(), cacheFiles) + if m3uErr != nil { + log.WithError(m3uErr).Errorln("unable to get m3u file") + return nil, nil, nil, m3uErr } - sort.Slice(l.xmlTv.Channels, func(i, j int) bool { - first, _ := strconv.Atoi(l.xmlTv.Channels[i].ID) - second, _ := strconv.Atoi(l.xmlTv.Channels[j].ID) - return first < second - }) + rawPlaylist, err := m3u.Decode(reader) + if err != nil { + log.WithError(err).Errorln("unable to parse m3u file") + return nil, nil, nil, err + } - playlist.FilteredTracksCount = len(playlist.Tracks) - exposedChannels.Add(float64(playlist.FilteredTracksCount)) - log.Debugf("Added %d channels to the lineup", playlist.FilteredTracksCount) + channelMap, programmeMap, epgErr := l.prepareEPG(provider, cacheFiles) + if epgErr != nil { + log.WithError(epgErr).Errorln("error when parsing EPG") + return nil, nil, nil, epgErr + } - return playlist, nil + return rawPlaylist, channelMap, programmeMap, nil } -func (l Lineup) processTrack(provider providers.Provider, track Track) (*Track, int, bool, error) { +func (l *lineup) processProviderChannel(channel *providers.ProviderChannel, programmeMap map[string][]xmltv.Programme) (*providers.ProviderChannel, error) { + if channel.EPGChannel != nil { + channel.EPGProgrammes = programmeMap[channel.EPGMatch] + } - hd := hdRegex.MatchString(strings.ToLower(track.Track.Raw)) - channelNumber := l.channelNumber + if !l.xmlTVChannelNumbers || channel.Number == 0 { + channel.Number = l.assignedChannelNumber + l.assignedChannelNumber = l.assignedChannelNumber + 1 + } - if xmlChan, ok := l.xmlTvChannelMap[track.TvgID]; ok { - log.Debugln("found an entry in xmlTvChannelMap for", track.Name) - if l.xmlTVChannelNumbers && xmlChan.Number != 0 { - channelNumber = xmlChan.Number - } else { - xmlChan.Number = channelNumber - } - l.channelsInXMLTv = append(l.channelsInXMLTv, track.TvgID) - track.XMLTVChannel = &xmlChan - l.xmlTv.Channels = append(l.xmlTv.Channels, xmlChan.RemappedChannel(track)) - if xmlChan.Programmes != nil { - track.XMLTVProgrammes = &xmlChan.Programmes - for _, programme := range xmlChan.Programmes { - newProgramme := programme - for idx, title := range programme.Titles { - programme.Titles[idx].Value = strings.Replace(title.Value, " [New!]", "", -1) // Hardcoded fix for Vaders - } - newProgramme.Channel = strconv.Itoa(channelNumber) - if hd { - if newProgramme.Video == nil { - newProgramme.Video = &xmltv.Video{} - } - newProgramme.Video.Quality = "HDTV" - } - l.xmlTv.Programmes = append(l.xmlTv.Programmes, newProgramme) - } - } + if channel.EPGChannel != nil && channel.EPGChannel.LCN == 0 { + channel.EPGChannel.LCN = channel.Number } - return &track, channelNumber, hd, nil + if channel.Logo != "" && channel.EPGChannel != nil && !containsIcon(channel.EPGChannel.Icons, channel.Logo) { + channel.EPGChannel.Icons = append(channel.EPGChannel.Icons, xmltv.Icon{Source: channel.Logo}) + } + + return channel, nil } -// Refresh will rescan all playlists for any channel changes. -func (l Lineup) Refresh() error { +func (l *lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool { + config := provider.Configuration() + if config.Filter == "" { + return true + } - if l.Refreshing { - log.Warnln("A refresh is already underway yet, another one was requested") - return nil + filterRegex, regexErr := regexp.Compile(config.Filter) + if regexErr != nil { + log.WithError(regexErr).Panicln("your regex is invalid") + return false } - log.Warnln("Refreshing the lineup!") + if config.FilterRaw { + return filterRegex.MatchString(track.Raw) + } - l.Refreshing = true + log.Debugf("track.Tags %+v", track.Tags) - existingPlaylists := make([]Playlist, len(l.Playlists)) - copy(existingPlaylists, l.Playlists) + filterKey := provider.RegexKey() + if config.FilterKey != "" { + if key, ok := track.Tags[config.FilterKey]; key != "" && ok { + filterKey = config.FilterKey + } else { + log.Panicf("the provided filter key (%s) does not exist or is blank", config.FilterKey) + } + } - l.Playlists = nil - l.TracksCount = 0 - l.FilteredTracksCount = 0 - l.StartingChannelNumber = 0 + if _, ok := track.Tags[filterKey]; !ok { + log.Panicf("Provided filter key %s doesn't exist in M3U tags", filterKey) + } - // FIXME: Re-implement AddProvider to use a provider. - // for _, playlist := range existingPlaylists { - // if addErr := l.AddProvider(playlist.M3UFile.Path); addErr != nil { - // return addErr - // } - // } + log.Debugf("Checking if filter (%s) matches string %s", config.Filter, track.Tags[filterKey]) - log.Infoln("Done refreshing the lineup!") + return filterRegex.MatchString(track.Tags[filterKey]) - l.LastRefreshed = time.Now() - l.Refreshing = false +} - return nil +func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { + var epg *xmltv.TV + epgChannelMap := make(map[string]xmltv.Channel) + epgProgrammeMap := make(map[string][]xmltv.Programme) + if provider.EPGURL() != "" { + var epgErr error + epg, epgErr = getXMLTV(provider.EPGURL(), cacheFiles) + if epgErr != nil { + return epgChannelMap, epgProgrammeMap, epgErr + } + + for _, channel := range epg.Channels { + epgChannelMap[channel.ID] = channel + + for _, programme := range epg.Programmes { + if programme.Channel == channel.ID { + epgProgrammeMap[channel.ID] = append(epgProgrammeMap[channel.ID], *provider.ProcessProgramme(programme)) + } + } + } + } + + return epgChannelMap, epgProgrammeMap, nil } -func (l *Lineup) getM3U(path string) (io.Reader, *M3UFile, error) { +func getM3U(path string, cacheFiles bool) (io.Reader, error) { safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) log.Infof("Loading M3U from %s", safePath) - file, transport, err := l.getFile(path) + file, _, err := getFile(path, cacheFiles) if err != nil { - return nil, nil, err + return nil, err } - return file, &M3UFile{ - Path: path, - SafePath: safePath, - Transport: transport, - }, nil + return file, nil } -func (l *Lineup) getXMLTV(path string) (*xmltv.TV, error) { - file, _, err := l.getFile(path) +func getXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { + safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + log.Infof("Loading XMLTV from %s", safePath) + file, _, err := getFile(path, cacheFiles) if err != nil { return nil, err } @@ -376,118 +320,69 @@ func (l *Lineup) getXMLTV(path string) (*xmltv.TV, error) { return tvSetup, nil } -func (l *Lineup) getFile(path string) (io.Reader, string, error) { - safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) - log.Infof("Loading file from %s", safePath) - +func getFile(path string, cacheFiles bool) (io.Reader, string, error) { transport := "disk" if strings.HasPrefix(strings.ToLower(path), "http") { + resp, err := http.Get(path) if err != nil { return nil, transport, err } - //defer resp.Body.Close() - return resp.Body, transport, nil - } - - file, fileErr := os.Open(path) - if fileErr != nil { - return nil, transport, fileErr - } - - return file, transport, nil -} - -type xmlTVChannel struct { - ID string - Number int - CallSign string - ShortName string - LongName string + // defer func() { + // err := resp.Body.Close() + // if err != nil { + // log.WithError(err).Panicln("error when closing HTTP body reader") + // } + // }() + + if strings.HasSuffix(strings.ToLower(path), ".gz") { + log.Infof("File (%s) is gzipp'ed, ungzipping now, this might take a while", path) + gz, gzErr := gzip.NewReader(resp.Body) + if gzErr != nil { + return nil, transport, gzErr + } - NumberAssigned bool + defer func() { + err := gz.Close() + if err != nil { + log.WithError(err).Panicln("error when closing gzip reader") + } + }() - Programmes []xmltv.Programme + if cacheFiles { + return writeFile(path, transport, gz) + } - Original xmltv.Channel -} + return gz, transport, nil + } -func (x *xmlTVChannel) RemappedChannel(t Track) xmltv.Channel { - newX := x.Original - newX.ID = strconv.Itoa(x.Number) - if t.TvgLogo != "" { - newX.Icons = append(newX.Icons, xmltv.Icon{Source: t.TvgLogo}) - } - if t.Track.Name != "" { - newX.DisplayNames = append(newX.DisplayNames, xmltv.CommonElement{Value: t.Track.Name}) - } - return newX -} + if cacheFiles { + return writeFile(path, transport, resp.Body) + } -func (l *Lineup) processXMLTV(tv *xmltv.TV) (map[string]xmlTVChannel, error) { - programmeMap := make(map[string][]xmltv.Programme) - for _, programme := range tv.Programmes { - programmeMap[programme.Channel] = append(programmeMap[programme.Channel], programme) + return resp.Body, transport, nil } - channelMap := make(map[string]xmlTVChannel, 0) - for _, tvChann := range tv.Channels { - xTVChan := &xmlTVChannel{ - ID: tvChann.ID, - Original: tvChann, - } - if programmes, ok := programmeMap[tvChann.ID]; ok { - xTVChan.Programmes = programmes - } - if channelNumberRegex(tvChann.ID) { - xTVChan.Number, _ = strconv.Atoi(tvChann.ID) - } - displayNames := []string{} - for _, displayName := range tvChann.DisplayNames { - displayNames = append(displayNames, displayName.Value) - } - sort.StringSlice(displayNames).Sort() - for i := 0; i < 10; i++ { - extractDisplayNames(displayNames, xTVChan) - } - channelMap[xTVChan.ID] = *xTVChan - // Duplicate this to first display-name just in case the M3U and XMLTV differ significantly. - for _, dn := range tvChann.DisplayNames { - channelMap[dn.Value] = *xTVChan - } + file, fileErr := os.Open(path) + if fileErr != nil { + return nil, transport, fileErr } - return channelMap, nil + return file, transport, nil } -func extractDisplayNames(displayNames []string, xTVChan *xmlTVChannel) { - for _, displayName := range displayNames { - if channelNumberRegex(displayName) { - if chanNum, chanNumErr := strconv.Atoi(displayName); chanNumErr == nil { - log.Debugln(displayName, "is channel number!") - xTVChan.Number = chanNum - } - } else if !strings.HasPrefix(displayName, fmt.Sprintf("%d", xTVChan.Number)) { - if xTVChan.LongName == "" { - xTVChan.LongName = displayName - log.Debugln(displayName, "is long name!") - } else if !callSignRegex(displayName) && len(xTVChan.LongName) < len(displayName) { - xTVChan.ShortName = xTVChan.LongName - xTVChan.LongName = displayName - log.Debugln(displayName, "is NEW long name, replacing", xTVChan.ShortName) - } else if callSignRegex(displayName) { - xTVChan.CallSign = displayName - log.Debugln(displayName, "is call sign!") - } - } - } +func writeFile(path, transport string, reader io.Reader) (io.Reader, string, error) { + // buf := new(bytes.Buffer) + // buf.ReadFrom(reader) + // buf.Bytes() + return reader, transport, nil } -func channelExists(s []HDHomeRunChannel, e HDHomeRunChannel) bool { - for _, a := range s { - if a.GuideName == e.GuideName { +func containsIcon(s []xmltv.Icon, e string) bool { + for _, ss := range s { + if e == ss.Source { return true } } diff --git a/main.go b/main.go index 7746d66..66fb61f 100644 --- a/main.go +++ b/main.go @@ -27,7 +27,6 @@ var ( Hooks: make(logrus.LevelHooks), Level: logrus.DebugLevel, } - opts = config{} exposedChannels = prometheus.NewGauge( prometheus.GaugeOpts{ @@ -71,8 +70,8 @@ func main() { flag.String("filter.regex", ".*", "Use regex to filter for channels that you want. A basic example would be .*UK.*. $(TELLY_FILTER_REGEX)") // Web flags - flag.String("web.listen-address", "localhost:6077", "Address to listen on for web interface and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") - flag.String("web.base-address", "localhost:6077", "The address to expose via discovery. Useful with reverse proxy $(TELLY_WEB_BASE_ADDRESS)") + flag.StringP("web.listen-address", "l", "localhost:6077", "Address to listen on for web interface and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") + flag.StringP("web.base-address", "b", "localhost:6077", "The address to expose via discovery. Useful with reverse proxy $(TELLY_WEB_BASE_ADDRESS)") // Log flags flag.String("log.level", logrus.InfoLevel.String(), "Only log messages with the given severity or above. Valid levels: [debug, info, warn, error, fatal] $(TELLY_LOG_LEVEL)") @@ -84,25 +83,63 @@ func main() { flag.Int("iptv.starting-channel", 10000, "The channel number to start exposing from. $(TELLY_IPTV_STARTING_CHANNEL)") flag.Bool("iptv.xmltv-channels", true, "Use channel numbers discovered via XMLTV file, if provided. $(TELLY_IPTV_XMLTV_CHANNELS)") + // Misc flags + flag.StringP("config.file", "c", "", "Path to your config file. If not set, configuration is searched for in the current working directory, $HOME/.telly/ and /etc/telly/. If provided, it will override all other arguments and environment variables. $(TELLY_CONFIG_FILE)") + flag.Bool("version", false, "Show application version") + flag.CommandLine.AddGoFlagSet(fflag.CommandLine) + + deprecatedFlags := []string{ + "discovery.device-id", + "discovery.device-friendly-name", + "discovery.device-auth", + "discovery.device-manufacturer", + "discovery.device-model-number", + "discovery.device-firmware-name", + "discovery.device-firmware-version", + "discovery.ssdp", + "iptv.playlist", + "iptv.streams", + "iptv.starting-channel", + "iptv.xmltv-channels", + "filter.regex-inclusive", + "filter.regex", + } + + for _, depFlag := range deprecatedFlags { + if depErr := flag.CommandLine.MarkDeprecated(depFlag, "use the configuration file instead."); depErr != nil { + log.WithError(depErr).Panicf("error marking flag %s as deprecated", depFlag) + } + } + flag.Parse() - viper.BindPFlags(flag.CommandLine) - viper.SetConfigName("telly.config") // name of config file (without extension) - viper.AddConfigPath("/etc/telly/") // path to look for the config file in - viper.AddConfigPath("$HOME/.telly") // call multiple times to add many search paths - viper.AddConfigPath(".") // optionally look for config in the working directory - viper.SetEnvPrefix(namespace) - viper.AutomaticEnv() - err := viper.ReadInConfig() // Find and read the config file - if err != nil { // Handle errors reading the config file + if bindErr := viper.BindPFlags(flag.CommandLine); bindErr != nil { + log.WithError(bindErr).Panicln("error binding flags to viper") + } + + if flag.Lookup("version").Changed { + fmt.Println(version.Print(namespace)) + os.Exit(0) + } + + if flag.Lookup("config.file").Changed { + viper.SetConfigFile(flag.Lookup("config.file").Value.String()) + } else { + viper.SetConfigName("telly.config") + viper.AddConfigPath("/etc/telly/") + viper.AddConfigPath("$HOME/.telly") + viper.AddConfigPath(".") + viper.SetEnvPrefix(namespace) + viper.AutomaticEnv() + } + + err := viper.ReadInConfig() + if err != nil { if _, ok := err.(viper.ConfigFileNotFoundError); !ok { log.WithError(err).Panicln("fatal error while reading config file:") } } - log.Infoln("Starting telly", version.Info()) - log.Infoln("Build context", version.BuildContext()) - prometheus.MustRegister(version.NewCollector("telly"), exposedChannels) level, parseLevelErr := logrus.ParseLevel(viper.GetString("log.level")) @@ -111,11 +148,32 @@ func main() { } log.SetLevel(level) + log.Infoln("telly is preparing to go live", version.Info()) + log.Debugln("Build context", version.BuildContext()) + + validateConfig() + + viper.Set("discovery.device-friendly-name", fmt.Sprintf("HDHomerun (%s)", viper.GetString("discovery.device-friendly-name"))) + viper.Set("discovery.device-uuid", fmt.Sprintf("%d-AE2A-4E54-BBC9-33AF7D5D6A92", viper.GetInt("discovery.device-id"))) + if log.Level == logrus.DebugLevel { - js, _ := json.MarshalIndent(viper.AllSettings(), "", " ") + js, jsErr := json.MarshalIndent(viper.AllSettings(), "", " ") + if jsErr != nil { + log.WithError(jsErr).Panicln("error marshal indenting viper config to JSON") + } log.Debugf("Loaded configuration %s", js) } + lineup := newLineup() + + if scanErr := lineup.Scan(); scanErr != nil { + log.WithError(scanErr).Panicln("Error scanning lineup!") + } + + serve(lineup) +} + +func validateConfig() { if viper.IsSet("filter.regexstr") { if _, regexErr := regexp.Compile(viper.GetString("filter.regex")); regexErr != nil { log.WithError(regexErr).Panicln("Error when compiling regex, is it valid?") @@ -127,33 +185,17 @@ func main() { log.WithError(addrErr).Panic("Error when parsing Listen address, please check the address and try again.") return } + if _, addrErr = net.ResolveTCPAddr("tcp", viper.GetString("web.base-address")); addrErr != nil { log.WithError(addrErr).Panic("Error when parsing Base addresses, please check the address and try again.") return } - if GetTCPAddr("web.base-address").IP.IsUnspecified() { + if getTCPAddr("web.base-address").IP.IsUnspecified() { log.Panicln("base URL is set to 0.0.0.0, this will not work. please use the --web.baseaddress option and set it to the (local) ip address telly is running on.") } - if GetTCPAddr("web.listenaddress").IP.IsUnspecified() && GetTCPAddr("web.base-address").IP.IsLoopback() { + if getTCPAddr("web.listenaddress").IP.IsUnspecified() && getTCPAddr("web.base-address").IP.IsLoopback() { log.Warnln("You are listening on all interfaces but your base URL is localhost (meaning Plex will try and load localhost to access your streams) - is this intended?") } - - viper.Set("discovery.device-friendly-name", fmt.Sprintf("HDHomerun (%s)", viper.GetString("discovery.device-friendly-name"))) - viper.Set("discovery.device-uuid", fmt.Sprintf("%d-AE2A-4E54-BBC9-33AF7D5D6A92", viper.GetInt("discovery.device-id"))) - - if flag.Lookup("iptv.playlist").Changed { - viper.Set("playlists.default.m3u", flag.Lookup("iptv.playlist").Value.String()) - } - - lineup := NewLineup() - - log.Infof("Loaded %d channels into the lineup", lineup.FilteredTracksCount) - - if lineup.FilteredTracksCount > 420 { - log.Panicf("telly has loaded more than 420 channels (%d) into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You must use regular expressions to filter out channels. You can also start another Telly instance.", lineup.FilteredTracksCount) - } - - serve(lineup) } diff --git a/providers/iptv-epg.go b/providers/iptv-epg.go deleted file mode 100644 index d1af649..0000000 --- a/providers/iptv-epg.go +++ /dev/null @@ -1,4 +0,0 @@ -package providers - -// M3U: http://iptv-epg.com/.m3u -// XMLTV: http://iptv-epg.com/.xml diff --git a/providers/main.go b/providers/main.go deleted file mode 100644 index ad7bbe3..0000000 --- a/providers/main.go +++ /dev/null @@ -1,97 +0,0 @@ -package providers - -import ( - "fmt" - "regexp" - "strings" - - log "github.com/sirupsen/logrus" - "github.com/tombowditch/telly/m3u" -) - -var channelNumberExtractor = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch - -type Configuration struct { - Name string `json:"-"` - Provider string - - Username string `json:"username"` - Password string `json:"password"` - - M3U string `json:"-"` - EPG string `json:"-"` - - VideoOnDemand bool `json:"-"` -} - -func (i *Configuration) GetProvider() (Provider, error) { - switch strings.ToLower(i.Provider) { - case "vaders": - log.Infoln("Source is vaders!") - return newVaders(i) - case "custom": - default: - log.Infoln("source is either custom or unknown, assuming custom!") - } - return nil, nil -} - -// ProviderChannel describes a channel available in the providers lineup with necessary pieces parsed into fields. -type ProviderChannel struct { - Name string - InternalID int // Should be the integer just before .ts. - Number *int - Logo string - StreamURL string - HD bool - Quality string - OnDemand bool - StreamFormat string -} - -// Provider describes a IPTV provider configuration. -type Provider interface { - Name() string - PlaylistURL() string - EPGURL() string - - // These are functions to extract information from playlists. - ParseLine(line m3u.Track) (*ProviderChannel, error) - - AuthenticatedStreamURL(channel *ProviderChannel) string - - MatchPlaylistKey() string -} - -// UnmarshalProviders takes V, a slice of Configuration and transforms it into a slice of Provider. -func UnmarshalProviders(v interface{}) ([]Provider, error) { - providers := make([]Provider, 0) - - uncasted, ok := v.([]interface{}) - if !ok { - panic(fmt.Errorf("provided slice is not of type []Configuration, it is of type %T", v)) - } - - for _, uncastedProvider := range uncasted { - ipProvider := uncastedProvider.(Configuration) - log.Infof("ipProvider %+v", ipProvider) - } - - return providers, nil -} - -// func testProvider() { -// v, vErr := NewVadersTV("hunter1", "hunter2", false) -// if vErr != nil { -// log.WithError(vErr).Errorf("Error setting up %s", v.Name()) -// } -// log.Infoln("Provider name is", v.Name()) -// log.Infoln("Playlist URL is", v.PlaylistURL()) -// log.Infoln("EPG URL is", v.EPGURL()) -// log.Infof("Stream URL is %+v", v.AuthenticatedStreamURL(&ProviderChannel{ -// Name: "Test channel", -// InternalID: 2862, -// })) - -// return -// } diff --git a/providers/vaders.go b/providers/vaders.go deleted file mode 100644 index a324c39..0000000 --- a/providers/vaders.go +++ /dev/null @@ -1,72 +0,0 @@ -package providers - -import ( - "encoding/base64" - "encoding/json" - "fmt" - "strconv" - "strings" - - "github.com/tombowditch/telly/m3u" -) - -// M3U: http://api.vaders.tv/vget?username=xxx&password=xxx&format=ts -// XMLTV: http://vaders.tv/p2.xml - -type vader struct { - provider Configuration - - Token string `json:"-"` -} - -func newVaders(config *Configuration) (Provider, error) { - tok, tokErr := json.Marshal(config) - if tokErr != nil { - return nil, tokErr - } - - return &vader{*config, base64.StdEncoding.EncodeToString(tok)}, nil -} - -func (v *vader) Name() string { - return "Vaders.tv" -} - -func (v *vader) PlaylistURL() string { - return fmt.Sprintf("http://api.vaders.tv/vget?username=%s&password=%s&vod=%t&format=ts", v.provider.Username, v.provider.Password, v.provider.VideoOnDemand) -} - -func (v *vader) EPGURL() string { - return "http://vaders.tv/p2.xml" -} - -func (v *vader) ParseLine(line m3u.Track) (*ProviderChannel, error) { - streamURL := channelNumberExtractor(line.URI, -1)[0] - channelID, channelIDErr := strconv.Atoi(streamURL[1]) - if channelIDErr != nil { - return nil, channelIDErr - } - - // http://vapi.vaders.tv/play/dvr/${start}/TSID.ts?duration=3600&token= - // http://vapi.vaders.tv/play/TSID.ts?token= - // http://vapi.vaders.tv/play/vod/VODID.mp4.m3u8?token= - // http://vapi.vaders.tv/play/vod/VODID.avi.m3u8?token= - // http://vapi.vaders.tv/play/vod/VODID.mkv.m3u8?token= - - return &ProviderChannel{ - Name: line.Tags["tvg-name"], - Logo: line.Tags["tvg-logo"], - StreamURL: line.URI, - InternalID: channelID, - HD: strings.Contains(strings.ToLower(line.Tags["tvg-name"]), "hd"), - StreamFormat: streamURL[2], - }, nil -} - -func (v *vader) AuthenticatedStreamURL(channel *ProviderChannel) string { - return fmt.Sprintf("http://vapi.vaders.tv/play/%d.ts?token=%s", channel.InternalID, v.Token) -} - -func (v *vader) MatchPlaylistKey() string { - return "tvg-id" -} diff --git a/routes.go b/routes.go index 26a2012..774b499 100644 --- a/routes.go +++ b/routes.go @@ -5,24 +5,29 @@ import ( "fmt" "net/http" "sort" + "strconv" + "strings" "time" "github.com/gin-gonic/gin" ssdp "github.com/koron/go-ssdp" "github.com/sirupsen/logrus" "github.com/spf13/viper" - ginprometheus "github.com/zsais/go-gin-prometheus" + ginprometheus "github.com/tombowditch/telly/internal/go-gin-prometheus" + "github.com/tombowditch/telly/internal/xmltv" ) -func serve(lineup *Lineup) { - discoveryData := GetDiscoveryData() +func serve(lineup *lineup) { + discoveryData := getDiscoveryData() log.Debugln("creating device xml") upnp := discoveryData.UPNP() log.Debugln("creating webserver routes") - gin.SetMode(gin.ReleaseMode) + if viper.GetString("log.level") != logrus.DebugLevel.String() { + gin.SetMode(gin.ReleaseMode) + } router := gin.New() router.Use(gin.Recovery()) @@ -43,7 +48,7 @@ func serve(lineup *Lineup) { Source: "Cable", SourceList: []string{"Cable"}, } - if lineup.Refreshing { + if lineup.Scanning { payload = LineupStatus{ ScanInProgress: convertibleBoolean(true), // Gotta fake out Plex. @@ -57,7 +62,7 @@ func serve(lineup *Lineup) { router.POST("/lineup.post", func(c *gin.Context) { scanAction := c.Query("scan") if scanAction == "start" { - if refreshErr := lineup.Refresh(); refreshErr != nil { + if refreshErr := lineup.Scan(); refreshErr != nil { c.AbortWithError(http.StatusInternalServerError, refreshErr) } c.AbortWithStatus(http.StatusOK) @@ -70,6 +75,7 @@ func serve(lineup *Lineup) { }) router.GET("/device.xml", deviceXML(upnp)) router.GET("/lineup.json", serveLineup(lineup)) + router.GET("/lineup.xml", serveLineup(lineup)) router.GET("/auto/:channelID", stream(lineup)) router.GET("/epg.xml", xmlTV(lineup)) router.GET("/debug.json", func(c *gin.Context) { @@ -82,7 +88,9 @@ func serve(lineup *Lineup) { } } - log.Infof("Listening and serving HTTP on %s", viper.GetString("web.listen-address")) + log.Infof("telly is live and on the air!") + log.Infof("Broadcasting on %s", viper.GetString("web.listen-address")) + log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) if err := router.Run(viper.GetString("web.listen-address")); err != nil { log.WithError(err).Panicln("Error starting up web server") } @@ -100,40 +108,71 @@ func discovery(data DiscoveryData) gin.HandlerFunc { } } -func lineupStatus(status LineupStatus) gin.HandlerFunc { - return func(c *gin.Context) { - c.JSON(http.StatusOK, status) - } +type hdhrLineupContainer struct { + XMLName xml.Name `xml:"Lineup" json:"-"` + Programs []hdHomeRunLineupItem } -func serveLineup(lineup *Lineup) gin.HandlerFunc { +func serveLineup(lineup *lineup) gin.HandlerFunc { return func(c *gin.Context) { - allChannels := make([]HDHomeRunChannel, 0) - for _, playlist := range lineup.Playlists { - allChannels = append(allChannels, playlist.Channels...) + channels := make([]hdHomeRunLineupItem, 0) + for _, channel := range lineup.channels { + channels = append(channels, channel) + } + sort.Slice(channels, func(i, j int) bool { + return channels[i].GuideNumber < channels[j].GuideNumber + }) + if strings.HasSuffix(c.Request.URL.String(), ".xml") { + buf, marshallErr := xml.MarshalIndent(hdhrLineupContainer{Programs: channels}, "", "\t") + if marshallErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling lineup to XML")) + } + c.Data(http.StatusOK, "application/xml", []byte(``+"\n"+string(buf))) + return } - sort.Slice(allChannels, func(i, j int) bool { return allChannels[i].GuideNumber < allChannels[j].GuideNumber }) - c.JSON(http.StatusOK, allChannels) + c.JSON(http.StatusOK, channels) } } -func xmlTV(lineup *Lineup) gin.HandlerFunc { +func xmlTV(lineup *lineup) gin.HandlerFunc { + epg := &xmltv.TV{ + GeneratorInfoName: namespaceWithVersion, + GeneratorInfoURL: "https://github.com/tombowditch/telly", + } + + for _, channel := range lineup.channels { + if channel.providerChannel.EPGChannel != nil { + epg.Channels = append(epg.Channels, *channel.providerChannel.EPGChannel) + epg.Programmes = append(epg.Programmes, channel.providerChannel.EPGProgrammes...) + } + } + + sort.Slice(epg.Channels, func(i, j int) bool { return epg.Channels[i].LCN < epg.Channels[j].LCN }) + return func(c *gin.Context) { - buf, _ := xml.MarshalIndent(lineup.xmlTv, "", "\t") + buf, marshallErr := xml.MarshalIndent(epg, "", "\t") + if marshallErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling EPG to XML")) + } c.Data(http.StatusOK, "application/xml", []byte(xml.Header+``+"\n"+string(buf))) } } -func stream(lineup *Lineup) gin.HandlerFunc { +func stream(lineup *lineup) gin.HandlerFunc { return func(c *gin.Context) { - channelID := c.Param("channelID")[1:] + channelIDStr := c.Param("channelID")[1:] + channelID, channelIDErr := strconv.Atoi(channelIDStr) + if channelIDErr != nil { + c.AbortWithError(http.StatusBadRequest, fmt.Errorf("that (%s) doesn't appear to be a valid channel number", channelIDStr)) + return + } - if url, ok := lineup.chanNumToURLMap[channelID]; ok { - log.Infof("Serving channel number %s", channelID) - c.Redirect(http.StatusMovedPermanently, url) + if channel, ok := lineup.channels[channelID]; ok { + log.Infof("Serving channel number %d", channelID) + c.Redirect(http.StatusMovedPermanently, channel.providerChannel.Track.URI) return } - c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %s", channelID)) + c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %d", channelID)) } } diff --git a/structs.go b/structs.go index 40d169b..c3977a3 100644 --- a/structs.go +++ b/structs.go @@ -4,51 +4,8 @@ import ( "encoding/json" "encoding/xml" "fmt" - "net" - "regexp" ) -type config struct { - Filter struct { - RegexInclusive bool `toml:"Filter.RegexInclusive"` - Regex *regexp.Regexp `toml:"-"` - RegexStr string `toml:"Filter.Regex"` - } - - IPTV struct { - Playlists []string `toml:"IPTV.Playlists"` - ConcurrentStreams int `toml:"IPTV.ConcurrentStreams"` - StartingChannel int `toml:"IPTV.StartingChannel"` - XMLTVChannelNumbers bool `toml:"IPTV.XMLTVChannelNumbers"` - } - - Discovery struct { - DeviceAuth string `toml:"Discovery.DeviceAuth"` - DeviceID int `toml:"Discovery.DeviceID"` - DeviceUUID string `toml:"Discovery.DeviceUUID"` - FriendlyName string `toml:"Discovery.FriendlyName"` - Manufacturer string `toml:"Discovery.Manufacturer"` - ModelNumber string `toml:"Discovery.ModelNumber"` - FirmwareName string `toml:"Discovery.FirmwareName"` - FirmwareVersion string `toml:"Discovery.FirmwareVersion"` - SSDP bool `toml:"Discovery.SSDP"` - } - - Log struct { - LogRequests bool `toml:"Log.Requests"` - Level string `toml:"Log.Level"` - } - - Web struct { - ListenAddress *net.TCPAddr `toml:"-"` - BaseAddress *net.TCPAddr `toml:"-"` - ListenAddressStr string `toml:"Web.ListenAddress"` - BaseAddressStr string `toml:"Web.BaseAddress"` - } - - lineup *Lineup -} - // DiscoveryData contains data about telly to expose in the HDHomeRun format for Plex detection. type DiscoveryData struct { FriendlyName string @@ -136,3 +93,29 @@ func (bit *convertibleBoolean) UnmarshalJSON(data []byte) error { } return nil } + +// MarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 +func (bit *convertibleBoolean) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + var bitSetVar int8 + if *bit { + bitSetVar = 1 + } + + return e.EncodeElement(bitSetVar, start) +} + +// UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 +func (bit *convertibleBoolean) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + var asString string + if decodeErr := d.DecodeElement(&asString, &start); decodeErr != nil { + return decodeErr + } + if asString == "1" || asString == "true" { + *bit = true + } else if asString == "0" || asString == "false" { + *bit = false + } else { + return fmt.Errorf("Boolean unmarshal error: invalid input %s", asString) + } + return nil +} diff --git a/utils.go b/utils.go index a106b96..2bddd71 100644 --- a/utils.go +++ b/utils.go @@ -3,28 +3,26 @@ package main import ( "fmt" "net" - "regexp" "strconv" "github.com/spf13/viper" ) -func GetTCPAddr(key string) *net.TCPAddr { - addr, _ := net.ResolveTCPAddr("tcp", viper.GetString(key)) +func getTCPAddr(key string) *net.TCPAddr { + addr, addrErr := net.ResolveTCPAddr("tcp", viper.GetString(key)) + if addrErr != nil { + panic(fmt.Errorf("error parsing address %s: %s", viper.GetString(key), addrErr)) + } return addr } -func GetStringAsRegex(key string) *regexp.Regexp { - return regexp.MustCompile(viper.GetString(key)) -} - -func GetDiscoveryData() DiscoveryData { +func getDiscoveryData() DiscoveryData { return DiscoveryData{ FriendlyName: viper.GetString("discovery.device-friendly-name"), Manufacturer: viper.GetString("discovery.device-manufacturer"), ModelNumber: viper.GetString("discovery.device-model-number"), FirmwareName: viper.GetString("discovery.device-firmware-name"), - TunerCount: viper.GetInt("iptv.concurrent-streams"), + TunerCount: viper.GetInt("iptv.streams"), FirmwareVersion: viper.GetString("discovery.device-firmware-version"), DeviceID: strconv.Itoa(viper.GetInt("discovery.device-id")), DeviceAuth: viper.GetString("discovery.device-auth"), From 77985f93e2ff0ae2bdab8fd984901c88d2e8ce29 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 15 Aug 2018 18:47:03 -0700 Subject: [PATCH 008/182] Minor fixes around logging, XMLTV and more --- internal/providers/vaders.go | 4 ++++ internal/xmltv/xmltv.go | 2 +- lineup.go | 43 +++++++++++++++++++----------------- routes.go | 2 +- 4 files changed, 29 insertions(+), 22 deletions(-) diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go index bcb2fa6..9b0502f 100644 --- a/internal/providers/vaders.go +++ b/internal/providers/vaders.go @@ -117,10 +117,14 @@ func (v *vader) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) } func (v *vader) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { + isNew := false for idx, title := range programme.Titles { + isNew = strings.HasSuffix(title.Value, " [New!]") programme.Titles[idx].Value = strings.Replace(title.Value, " [New!]", "", -1) } + programme.New = xmltv.ElementPresent(isNew) + return &programme } diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 5567f1f..f75e3c1 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -93,7 +93,7 @@ type Programme struct { PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` - New ElementPresent `xml:"new>placeholder,omitempty" json:"new"` + New ElementPresent `xml:"new>placeholder,omitempty" json:"new,omitempty"` Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` diff --git a/lineup.go b/lineup.go index 3881f7c..d682687 100644 --- a/lineup.go +++ b/lineup.go @@ -73,7 +73,7 @@ func newLineup() *lineup { log.WithError(unmarshalErr).Panicln("Unable to unmarshal source configuration to slice of providers.Configuration, check your configuration!") } - if viper.IsSet("iptv.playlist") { + if viper.GetString("iptv.playlist") != "" { log.Warnln("Legacy --iptv.playlist argument or environment variable provided, using Custom provider with default configuration, this may fail! If so, you should use a configuration file for full flexibility.") regexStr := ".*" if viper.IsSet("filter.regex") { @@ -153,11 +153,16 @@ func (l *lineup) processProvider(provider providers.Provider) (int, error) { }) } + successChannels := []string{} + failedChannels := []string{} + for _, track := range m3u.Tracks { // First, we run the filter. if !l.FilterTrack(provider, track) { - log.Debugf("Channel %s didn't pass the provider (%s) filter, skipping!", track.Name, provider.Name()) - return addedChannels, nil + failedChannels = append(failedChannels, track.Name) + continue + } else { + successChannels = append(successChannels, track.Name) } // Then we do the provider specific translation to a hdHomeRunLineupItem. @@ -178,6 +183,9 @@ func (l *lineup) processProvider(provider providers.Provider) (int, error) { l.channels[channel.Number] = newHDHRItem(&provider, channel) } + log.Debugf("These channels (%d) passed the filter and successfully parsed: %s", len(successChannels), strings.Join(successChannels, ", ")) + log.Debugf("These channels (%d) did NOT pass the filter: %s", len(failedChannels), strings.Join(failedChannels, ", ")) + log.Infof("Loaded %d channels into the lineup from %s", addedChannels, provider.Name()) return addedChannels, nil @@ -198,6 +206,10 @@ func (l *lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, ma return nil, nil, nil, err } + if closeM3UErr := reader.Close(); closeM3UErr != nil { + log.WithError(closeM3UErr).Panicln("error when closing m3u reader") + } + channelMap, programmeMap, epgErr := l.prepareEPG(provider, cacheFiles) if epgErr != nil { log.WithError(epgErr).Errorln("error when parsing EPG") @@ -285,12 +297,13 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s } } } + } return epgChannelMap, epgProgrammeMap, nil } -func getM3U(path string, cacheFiles bool) (io.Reader, error) { +func getM3U(path string, cacheFiles bool) (io.ReadCloser, error) { safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) log.Infof("Loading M3U from %s", safePath) @@ -317,10 +330,14 @@ func getXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { return nil, err } + if closeXMLErr := file.Close(); closeXMLErr != nil { + log.WithError(closeXMLErr).Panicln("error when closing xml reader") + } + return tvSetup, nil } -func getFile(path string, cacheFiles bool) (io.Reader, string, error) { +func getFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { transport := "disk" if strings.HasPrefix(strings.ToLower(path), "http") { @@ -330,13 +347,6 @@ func getFile(path string, cacheFiles bool) (io.Reader, string, error) { return nil, transport, err } - // defer func() { - // err := resp.Body.Close() - // if err != nil { - // log.WithError(err).Panicln("error when closing HTTP body reader") - // } - // }() - if strings.HasSuffix(strings.ToLower(path), ".gz") { log.Infof("File (%s) is gzipp'ed, ungzipping now, this might take a while", path) gz, gzErr := gzip.NewReader(resp.Body) @@ -344,13 +354,6 @@ func getFile(path string, cacheFiles bool) (io.Reader, string, error) { return nil, transport, gzErr } - defer func() { - err := gz.Close() - if err != nil { - log.WithError(err).Panicln("error when closing gzip reader") - } - }() - if cacheFiles { return writeFile(path, transport, gz) } @@ -373,7 +376,7 @@ func getFile(path string, cacheFiles bool) (io.Reader, string, error) { return file, transport, nil } -func writeFile(path, transport string, reader io.Reader) (io.Reader, string, error) { +func writeFile(path, transport string, reader io.ReadCloser) (io.ReadCloser, string, error) { // buf := new(bytes.Buffer) // buf.ReadFrom(reader) // buf.Bytes() diff --git a/routes.go b/routes.go index 774b499..d708090 100644 --- a/routes.go +++ b/routes.go @@ -89,7 +89,7 @@ func serve(lineup *lineup) { } log.Infof("telly is live and on the air!") - log.Infof("Broadcasting on %s", viper.GetString("web.listen-address")) + log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) if err := router.Run(viper.GetString("web.listen-address")); err != nil { log.WithError(err).Panicln("Error starting up web server") From 3e09bbd81a2aa206028dfa36d03cfcdedd463e40 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 16 Aug 2018 15:08:07 -0700 Subject: [PATCH 009/182] Checkpoint on Schedules Direct before migrating to new repo --- internal/xmltv/xmltv.go | 23 +++- lineup.go | 243 ++++++++++++++++++++++++++++++++++++++++ 2 files changed, 265 insertions(+), 1 deletion(-) diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index f75e3c1..37c70c2 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -33,6 +33,27 @@ func (t *Time) UnmarshalXMLAttr(attr xml.Attr) error { return nil } +type Date struct { + time.Time +} + +func (c *Date) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + var v string + if decodeErr := d.DecodeElement(&v, &start); decodeErr != nil { + return decodeErr + } + dateFormat := "20060102" // yyyymmdd date format + if len(v) == 4 { + dateFormat = "2006" + } + parse, err := time.ParseInLocation(dateFormat, v, time.UTC) + if err != nil { + return err + } + *c = Date{parse} + return nil +} + // TV is the root element. type TV struct { XMLName xml.Name `xml:"tv" json:"-"` @@ -78,7 +99,7 @@ type Programme struct { SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondary_titles,omitempty"` Descriptions []CommonElement `xml:"desc,omitempty" json:"descriptions,omitempty"` Credits *Credits `xml:"credits,omitempty" json:"credits,omitempty"` - Date string `xml:"date,omitempty" json:"date,omitempty"` + Date Date `xml:"date,omitempty" json:"date,omitempty"` Categories []CommonElement `xml:"category,omitempty" json:"categories,omitempty"` Keywords []CommonElement `xml:"keyword,omitempty" json:"keywords,omitempty"` Languages []CommonElement `xml:"language,omitempty" json:"languages,omitempty"` diff --git a/lineup.go b/lineup.go index d682687..7153de0 100644 --- a/lineup.go +++ b/lineup.go @@ -9,8 +9,10 @@ import ( "os" "regexp" "sort" + "strconv" "strings" + "github.com/nathanjjohnson/GoSchedulesDirect" "github.com/spf13/viper" m3u "github.com/tombowditch/telly/internal/m3uplus" "github.com/tombowditch/telly/internal/providers" @@ -20,6 +22,7 @@ import ( // var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString // var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString // var hdRegex = regexp.MustCompile(`hd|4k`) +var xmlNSRegex = regexp.MustCompile(`(\d).(\d).(?:(\d)/(\d))?`) // hdHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. type hdHomeRunLineupItem struct { @@ -63,6 +66,8 @@ type lineup struct { xmlTVChannelNumbers bool channels map[int]hdHomeRunLineupItem + + sd *GoSchedulesDirect.Client } // newLineup returns a new lineup for the given config struct. @@ -94,6 +99,14 @@ func newLineup() *lineup { channels: make(map[int]hdHomeRunLineupItem), } + lineup.sd = GoSchedulesDirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) + + status, statusErr := lineup.sd.GetStatus() + if statusErr != nil { + panic(statusErr) + } + log.Infof("SD status %+v", status) + for _, cfg := range cfgs { provider, providerErr := cfg.GetProvider() if providerErr != nil { @@ -288,16 +301,61 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s return epgChannelMap, epgProgrammeMap, epgErr } + needsMoreInfo := make(map[string]xmltv.Programme) // TMSID:programme + haveAllInfo := make(map[string][]xmltv.Programme) // channel number:[]programme + for _, channel := range epg.Channels { epgChannelMap[channel.ID] = channel for _, programme := range epg.Programmes { if programme.Channel == channel.ID { epgProgrammeMap[channel.ID] = append(epgProgrammeMap[channel.ID], *provider.ProcessProgramme(programme)) + if len(programme.EpisodeNums) == 1 && programme.EpisodeNums[0].System == "dd_progid" { + needsMoreInfo[programme.EpisodeNums[0].Value] = programme + } else { + haveAllInfo[channel.ID] = append(haveAllInfo[channel.ID], *provider.ProcessProgramme(programme)) + } } } } + tmsIDs := make([]string, 0) + + // r := strings.NewReplacer("/", "", ".", "") + + for tmsID := range needsMoreInfo { + splitID := strings.Split(tmsID, ".") + tmsIDs = append(tmsIDs, fmt.Sprintf("%s%s", splitID[0], splitID[1])) + } + + log.Infof("GETTING %d programs from SD", len(tmsIDs)) + + //ids := []string{"EP00000204.0125.0/2", "EP00000204.0126.1/2", "EP03022620.0011.0/3", "EP03022786.0001", "EP03022786.0001", "EP03022786.0001", "EP03022786.0001", "EP03023628.0001", "EP03023750.0001", "EP03023787.0001", "EP03023787.0002", "EP03023971.0001", "EP03025363.0001", "EP03025363.0002", "EP03025363.0003", "EP03025363.0004", "EP03025363.0005", "EP03025363.0006", "EP03026541.0001", "EP03026541.0001", "EP03026541.0001", "EP03027284.0005", "EP03027284.0005", "EP03029229.0001", "MV00000031.0000", "SH00246313.0000", "SH02485979.0000.0/3", "SH02485979.0000.1/3"} + + allResponses := make([]GoSchedulesDirect.ProgramInfo, len(tmsIDs)) + + for _, chunk := range chunkStringSlice(tmsIDs, 5000) { + moreInfo, moreInfoErr := l.sd.GetProgramInfo(chunk) + if moreInfoErr != nil { + log.WithError(moreInfoErr).Errorln("Error when getting more program details from Schedules Direct") + return epgChannelMap, epgProgrammeMap, moreInfoErr + } + + allResponses = append(allResponses, moreInfo...) + } + + log.Infoln("Got %d responses from SD", len(allResponses)) + + for _, program := range allResponses { + newProgram := MergeSchedulesDirectAndXMLTVProgramme(needsMoreInfo[program.ProgramID], program) + log.Infof("newProgram %+v") + } + + //panic("bye") + + // needsMoreInfo + //epgProgrammeMap[channel.ID] = append(epgProgrammeMap[channel.ID], *provider.ProcessProgramme(programme)) + } return epgChannelMap, epgProgrammeMap, nil @@ -391,3 +449,188 @@ func containsIcon(s []xmltv.Icon, e string) bool { } return false } + +func chunkStringSlice(sl []string, chunkSize int) [][]string { + var divided [][]string + + for i := 0; i < len(sl); i += chunkSize { + end := i + chunkSize + + if end > len(sl) { + end = len(sl) + } + + divided = append(divided, sl[i:end]) + } + return divided +} + +func MergeSchedulesDirectAndXMLTVProgramme(programme xmltv.Programme, sdProgram GoSchedulesDirect.ProgramInfo) xmltv.Programme { + + allTitles := make([]string, 0) + + for _, title := range programme.Titles { + allTitles = append(allTitles, title.Value) + } + + for _, title := range sdProgram.Titles { + allTitles = append(allTitles, title.Title120) + } + + for _, title := range UniqueStrings(allTitles) { + programme.Titles = append(programme.Titles, xmltv.CommonElement{Value: title}) + } + + allKeywords := make([]string, 0) + + for _, keyword := range programme.Keywords { + allKeywords = append(allKeywords, keyword.Value) + } + + for keywordType, keywords := range sdProgram.Keywords { + log.Infoln("Adding keywords category", keywordType) + for _, keyword := range keywords { + allKeywords = append(allKeywords, keyword) + } + } + + // FIXME: We should really be making sure that we passthrough languages. + allDescriptions := make([]string, 0) + + for _, description := range programme.Descriptions { + allDescriptions = append(allDescriptions, description.Value) + } + + for _, descriptions := range sdProgram.Descriptions { + for _, description := range descriptions { + allDescriptions = append(allDescriptions, description.Description) + } + } + + for _, description := range UniqueStrings(allDescriptions) { + programme.Descriptions = append(programme.Descriptions, xmltv.CommonElement{Value: description}) + } + + for _, keyword := range UniqueStrings(allKeywords) { + programme.Keywords = append(programme.Keywords, xmltv.CommonElement{Value: keyword}) + } + + allRatings := make(map[string]string, 0) + + for _, rating := range programme.Ratings { + allRatings[rating.System] = rating.Value + } + + for _, rating := range sdProgram.ContentRating { + allRatings[rating.Body] = rating.Code + } + + for system, rating := range allRatings { + programme.Ratings = append(programme.Ratings, xmltv.Rating{Value: rating, System: system}) + } + + hasXMLTVNS := false + + for _, epNum := range programme.EpisodeNums { + if epNum.System == "xmltv_ns" { + hasXMLTVNS = true + } + } + + if !hasXMLTVNS { + seasonNumber := 0 + episodeNumber := 0 + numbersFilled := false + + for _, meta := range sdProgram.Metadata { + for _, metadata := range meta { + if metadata.Season != nil { + seasonNumber = *metadata.Season - 1 // SD metadata isnt 0 index + numbersFilled = true + } + if metadata.Episode != nil { + episodeNumber = *metadata.Episode - 1 + numbersFilled = true + } + } + } + + if numbersFilled { + // FIXME: There is currently no way to determine multipart episodes from SD. + // We could use the dd_progid to determine it though. + xmlTVNS := fmt.Sprintf("%d.%d.0/1", seasonNumber, episodeNumber) + programme.EpisodeNums = append(programme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmlTVNS}) + } + } + + return programme +} + +func extractXMLTVNS(str string) (int, int, int, int, error) { + matches := xmlNSRegex.FindAllStringSubmatch(str, -1) + + if len(matches) == 0 { + return 0, 0, 0, 0, fmt.Errorf("invalid xmltv_ns: %s", str) + } + + season, seasonErr := strconv.Atoi(matches[0][1]) + if seasonErr != nil { + return 0, 0, 0, 0, seasonErr + } + + episode, episodeErr := strconv.Atoi(matches[0][2]) + if episodeErr != nil { + return 0, 0, 0, 0, episodeErr + } + + currentPartNum := 0 + totalPartsNum := 0 + + if len(matches[0]) > 2 && matches[0][3] != "" { + currentPart, currentPartErr := strconv.Atoi(matches[0][3]) + if currentPartErr != nil { + return 0, 0, 0, 0, currentPartErr + } + currentPartNum = currentPart + } + + if len(matches[0]) > 3 && matches[0][4] != "" { + totalParts, totalPartsErr := strconv.Atoi(matches[0][4]) + if totalPartsErr != nil { + return 0, 0, 0, 0, totalPartsErr + } + totalPartsNum = totalParts + } + + // if season > 0 { + // season = season - 1 + // } + + // if episode > 0 { + // episode = episode - 1 + // } + + // if currentPartNum > 0 { + // currentPartNum = currentPartNum - 1 + // } + + // if totalPartsNum > 0 { + // totalPartsNum = totalPartsNum - 1 + // } + + return season, episode, currentPartNum, totalPartsNum, nil +} + +func UniqueStrings(input []string) []string { + u := make([]string, 0, len(input)) + m := make(map[string]bool) + + for _, val := range input { + if _, ok := m[val]; !ok { + m[val] = true + u = append(u, val) + } + } + + return u +} From 356841a1e9b6d2e012cea4d263d327fded9b508a Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 16 Aug 2018 15:12:55 -0700 Subject: [PATCH 010/182] Migrate to new repo --- internal/providers/custom.go | 4 ++-- internal/providers/iptv-epg.go | 4 ++-- internal/providers/main.go | 4 ++-- internal/providers/vaders.go | 4 ++-- lineup.go | 8 ++++---- routes.go | 6 +++--- 6 files changed, 15 insertions(+), 15 deletions(-) diff --git a/internal/providers/custom.go b/internal/providers/custom.go index e6a93c0..721ddc9 100644 --- a/internal/providers/custom.go +++ b/internal/providers/custom.go @@ -4,8 +4,8 @@ import ( "strconv" "strings" - m3u "github.com/tombowditch/telly/internal/m3uplus" - "github.com/tombowditch/telly/internal/xmltv" + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" ) type customProvider struct { diff --git a/internal/providers/iptv-epg.go b/internal/providers/iptv-epg.go index 63c5602..258239b 100644 --- a/internal/providers/iptv-epg.go +++ b/internal/providers/iptv-epg.go @@ -5,8 +5,8 @@ import ( "strconv" "strings" - m3u "github.com/tombowditch/telly/internal/m3uplus" - "github.com/tombowditch/telly/internal/xmltv" + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" ) // M3U: http://iptv-epg.com/.m3u diff --git a/internal/providers/main.go b/internal/providers/main.go index f772532..5931408 100644 --- a/internal/providers/main.go +++ b/internal/providers/main.go @@ -4,8 +4,8 @@ import ( "regexp" "strings" - m3u "github.com/tombowditch/telly/internal/m3uplus" - "github.com/tombowditch/telly/internal/xmltv" + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" ) var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go index 9b0502f..40d705b 100644 --- a/internal/providers/vaders.go +++ b/internal/providers/vaders.go @@ -9,8 +9,8 @@ import ( "strings" log "github.com/sirupsen/logrus" - m3u "github.com/tombowditch/telly/internal/m3uplus" - "github.com/tombowditch/telly/internal/xmltv" + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" ) // This regex matches and extracts the following URLs. diff --git a/lineup.go b/lineup.go index 7153de0..698f6ed 100644 --- a/lineup.go +++ b/lineup.go @@ -14,9 +14,9 @@ import ( "github.com/nathanjjohnson/GoSchedulesDirect" "github.com/spf13/viper" - m3u "github.com/tombowditch/telly/internal/m3uplus" - "github.com/tombowditch/telly/internal/providers" - "github.com/tombowditch/telly/internal/xmltv" + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/providers" + "github.com/tellytv/telly/internal/xmltv" ) // var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString @@ -348,7 +348,7 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s for _, program := range allResponses { newProgram := MergeSchedulesDirectAndXMLTVProgramme(needsMoreInfo[program.ProgramID], program) - log.Infof("newProgram %+v") + log.Infof("newProgram %+v", newProgram) } //panic("bye") diff --git a/routes.go b/routes.go index d708090..203dcef 100644 --- a/routes.go +++ b/routes.go @@ -13,8 +13,8 @@ import ( ssdp "github.com/koron/go-ssdp" "github.com/sirupsen/logrus" "github.com/spf13/viper" - ginprometheus "github.com/tombowditch/telly/internal/go-gin-prometheus" - "github.com/tombowditch/telly/internal/xmltv" + ginprometheus "github.com/tellytv/telly/internal/go-gin-prometheus" + "github.com/tellytv/telly/internal/xmltv" ) func serve(lineup *lineup) { @@ -137,7 +137,7 @@ func serveLineup(lineup *lineup) gin.HandlerFunc { func xmlTV(lineup *lineup) gin.HandlerFunc { epg := &xmltv.TV{ GeneratorInfoName: namespaceWithVersion, - GeneratorInfoURL: "https://github.com/tombowditch/telly", + GeneratorInfoURL: "https://github.com/tellytv/telly", } for _, channel := range lineup.channels { From 102cb5deff6c9a4f56a031a35a976d3c3331c2ae Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 16 Aug 2018 15:42:43 -0700 Subject: [PATCH 011/182] Finish hooking in SD --- lineup.go | 54 ++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 34 insertions(+), 20 deletions(-) diff --git a/lineup.go b/lineup.go index 698f6ed..168f055 100644 --- a/lineup.go +++ b/lineup.go @@ -99,12 +99,17 @@ func newLineup() *lineup { channels: make(map[int]hdHomeRunLineupItem), } - lineup.sd = GoSchedulesDirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) + sdClient := GoSchedulesDirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) - status, statusErr := lineup.sd.GetStatus() + // FIXME: Check that SD is online before continuing. + + status, statusErr := sdClient.GetStatus() if statusErr != nil { panic(statusErr) } + + lineup.sd = sdClient + log.Infof("SD status %+v", status) for _, cfg := range cfgs { @@ -301,7 +306,7 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s return epgChannelMap, epgProgrammeMap, epgErr } - needsMoreInfo := make(map[string]xmltv.Programme) // TMSID:programme + sdEligible := make(map[string]xmltv.Programme) // TMSID:programme haveAllInfo := make(map[string][]xmltv.Programme) // channel number:[]programme for _, channel := range epg.Channels { @@ -310,8 +315,16 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s for _, programme := range epg.Programmes { if programme.Channel == channel.ID { epgProgrammeMap[channel.ID] = append(epgProgrammeMap[channel.ID], *provider.ProcessProgramme(programme)) - if len(programme.EpisodeNums) == 1 && programme.EpisodeNums[0].System == "dd_progid" { - needsMoreInfo[programme.EpisodeNums[0].Value] = programme + ddProgID := "" + if viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") { + for _, epNum := range programme.EpisodeNums { + if epNum.System == "dd_progid" { + ddProgID = epNum.Value + } + } + } + if ddProgID != "" { + sdEligible[ddProgID] = programme } else { haveAllInfo[channel.ID] = append(haveAllInfo[channel.ID], *provider.ProcessProgramme(programme)) } @@ -321,16 +334,16 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s tmsIDs := make([]string, 0) - // r := strings.NewReplacer("/", "", ".", "") - - for tmsID := range needsMoreInfo { - splitID := strings.Split(tmsID, ".") - tmsIDs = append(tmsIDs, fmt.Sprintf("%s%s", splitID[0], splitID[1])) + for tmsID := range sdEligible { + cleanID := strings.Replace(tmsID, ".", "", -1) + if len(cleanID) < 14 { + log.Warnf("found an invalid TMS ID/dd_progid: %s", cleanID) + continue + } + tmsIDs = append(tmsIDs, cleanID[0:13]) } - log.Infof("GETTING %d programs from SD", len(tmsIDs)) - - //ids := []string{"EP00000204.0125.0/2", "EP00000204.0126.1/2", "EP03022620.0011.0/3", "EP03022786.0001", "EP03022786.0001", "EP03022786.0001", "EP03022786.0001", "EP03023628.0001", "EP03023750.0001", "EP03023787.0001", "EP03023787.0002", "EP03023971.0001", "EP03025363.0001", "EP03025363.0002", "EP03025363.0003", "EP03025363.0004", "EP03025363.0005", "EP03025363.0006", "EP03026541.0001", "EP03026541.0001", "EP03026541.0001", "EP03027284.0005", "EP03027284.0005", "EP03029229.0001", "MV00000031.0000", "SH00246313.0000", "SH02485979.0000.0/3", "SH02485979.0000.1/3"} + log.Infof("Requesting guide data for %d programs from Schedules Direct", len(tmsIDs)) allResponses := make([]GoSchedulesDirect.ProgramInfo, len(tmsIDs)) @@ -346,15 +359,16 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s log.Infoln("Got %d responses from SD", len(allResponses)) - for _, program := range allResponses { - newProgram := MergeSchedulesDirectAndXMLTVProgramme(needsMoreInfo[program.ProgramID], program) - log.Infof("newProgram %+v", newProgram) + for _, sdResponse := range allResponses { + mergedProgramme := MergeSchedulesDirectAndXMLTVProgramme(sdEligible[sdResponse.ProgramID], sdResponse) + haveAllInfo[mergedProgramme.Channel] = append(haveAllInfo[mergedProgramme.Channel], mergedProgramme) } - //panic("bye") - - // needsMoreInfo - //epgProgrammeMap[channel.ID] = append(epgProgrammeMap[channel.ID], *provider.ProcessProgramme(programme)) + for _, programmes := range haveAllInfo { + for _, programme := range programmes { + epgProgrammeMap[programme.Channel] = append(epgProgrammeMap[programme.Channel], *provider.ProcessProgramme(programme)) + } + } } From 1d1562e765dc17bd80e73a17f4c09826bc103263 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 14:31:02 -0700 Subject: [PATCH 012/182] More Schedules Direct fixes --- internal/xmltv/xmltv.go | 60 ++++++--- lineup.go | 277 ++++++++++++++++++++++++++++++++-------- 2 files changed, 267 insertions(+), 70 deletions(-) diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 37c70c2..1cf2ea6 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -3,6 +3,7 @@ package xmltv import ( "encoding/xml" + "fmt" "os" "time" @@ -33,24 +34,51 @@ func (t *Time) UnmarshalXMLAttr(attr xml.Attr) error { return nil } -type Date struct { - time.Time +type Date time.Time + +func (p Date) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + t := time.Time(p) + if t.IsZero() { + return e.EncodeElement(nil, start) + } + return e.EncodeElement(t.Format("20060102"), start) } -func (c *Date) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { - var v string - if decodeErr := d.DecodeElement(&v, &start); decodeErr != nil { - return decodeErr +func (p *Date) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) { + var content string + if e := d.DecodeElement(&content, &start); e != nil { + return fmt.Errorf("get the type Date field of %s error", start.Name.Local) } - dateFormat := "20060102" // yyyymmdd date format - if len(v) == 4 { - dateFormat = "2006" - } - parse, err := time.ParseInLocation(dateFormat, v, time.UTC) - if err != nil { - return err + + dateFormat := "20060102" + + if len(content) == 4 { + dateFormat = "2006" + } + + if v, e := time.Parse(dateFormat, content); e != nil { + return fmt.Errorf("the type Date field of %s is not a time, value is: %s", start.Name.Local, content) + } else { + *p = Date(v) + } + return nil +} + +func (p Date) MarshalJSON() ([]byte, error) { + t := time.Time(p) + str := "\"" + t.Format("20060102") + "\"" + + return []byte(str), nil +} + +func (p *Date) UnmarshalJSON(text []byte) (err error) { + strDate := string(text[1 : 8+1]) + + if v, e := time.Parse("20060102", strDate); e != nil { + return fmt.Errorf("Date should be a time, error value is: %s", strDate) + } else { + *p = Date(v) } - *c = Date{parse} return nil } @@ -114,7 +142,7 @@ type Programme struct { PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` - New ElementPresent `xml:"new>placeholder,omitempty" json:"new,omitempty"` + New ElementPresent `xml:"new" json:"new,omitempty"` Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` @@ -140,7 +168,7 @@ type ElementPresent bool // MarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 func (c *ElementPresent) MarshalXML(e *xml.Encoder, start xml.StartElement) error { - return e.EncodeElement(*c, start) + return e.EncodeElement(nil, start) } // UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 diff --git a/lineup.go b/lineup.go index 168f055..1d27dd7 100644 --- a/lineup.go +++ b/lineup.go @@ -12,8 +12,8 @@ import ( "strconv" "strings" - "github.com/nathanjjohnson/GoSchedulesDirect" "github.com/spf13/viper" + "github.com/tellytv/go.schedulesdirect" m3u "github.com/tellytv/telly/internal/m3uplus" "github.com/tellytv/telly/internal/providers" "github.com/tellytv/telly/internal/xmltv" @@ -23,6 +23,7 @@ import ( // var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString // var hdRegex = regexp.MustCompile(`hd|4k`) var xmlNSRegex = regexp.MustCompile(`(\d).(\d).(?:(\d)/(\d))?`) +var ddProgIDRegex = regexp.MustCompile(`(?m)(EP|SH|MV|SP)(\d{7,8}).(\d+).?(?:(\d).(\d))?`) // hdHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. type hdHomeRunLineupItem struct { @@ -67,7 +68,7 @@ type lineup struct { channels map[int]hdHomeRunLineupItem - sd *GoSchedulesDirect.Client + sd *schedulesdirect.Client } // newLineup returns a new lineup for the given config struct. @@ -99,19 +100,13 @@ func newLineup() *lineup { channels: make(map[int]hdHomeRunLineupItem), } - sdClient := GoSchedulesDirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) - - // FIXME: Check that SD is online before continuing. - - status, statusErr := sdClient.GetStatus() - if statusErr != nil { - panic(statusErr) + sdClient, sdClientErr := schedulesdirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) + if sdClientErr != nil { + log.WithError(sdClientErr).Panicln("error setting up schedules direct client") } lineup.sd = sdClient - log.Infof("SD status %+v", status) - for _, cfg := range cfgs { provider, providerErr := cfg.GetProvider() if providerErr != nil { @@ -153,6 +148,7 @@ func (l *lineup) processProvider(provider providers.Provider) (int, error) { m3u, channelMap, programmeMap, prepareErr := l.prepareProvider(provider) if prepareErr != nil { log.WithError(prepareErr).Errorln("error when preparing provider") + return 0, prepareErr } if provider.Configuration().SortKey != "" { @@ -306,6 +302,8 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s return epgChannelMap, epgProgrammeMap, epgErr } + augmentWithSD := viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") + sdEligible := make(map[string]xmltv.Programme) // TMSID:programme haveAllInfo := make(map[string][]xmltv.Programme) // channel number:[]programme @@ -314,54 +312,104 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s for _, programme := range epg.Programmes { if programme.Channel == channel.ID { - epgProgrammeMap[channel.ID] = append(epgProgrammeMap[channel.ID], *provider.ProcessProgramme(programme)) ddProgID := "" - if viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") { + if augmentWithSD { for _, epNum := range programme.EpisodeNums { if epNum.System == "dd_progid" { ddProgID = epNum.Value } } } - if ddProgID != "" { - sdEligible[ddProgID] = programme + if augmentWithSD == true && ddProgID != "" { + idType, uniqID, epID, _, _, extractErr := extractDDProgID(ddProgID) + if extractErr != nil { + log.WithError(extractErr).Errorln("error extracting dd_progid") + continue + } + cleanID := fmt.Sprintf("%s%s%s", idType, padNumberWithZero(uniqID, 8), padNumberWithZero(epID, 4)) + if len(cleanID) < 14 { + log.Warnf("found an invalid TMS ID/dd_progid, expected length of exactly 14, got %d: %s\n", len(cleanID), cleanID) + continue + } + + sdEligible[cleanID] = programme } else { - haveAllInfo[channel.ID] = append(haveAllInfo[channel.ID], *provider.ProcessProgramme(programme)) + haveAllInfo[channel.ID] = append(haveAllInfo[channel.ID], programme) } } } } - tmsIDs := make([]string, 0) + if augmentWithSD { + tmsIDs := make([]string, 0) - for tmsID := range sdEligible { - cleanID := strings.Replace(tmsID, ".", "", -1) - if len(cleanID) < 14 { - log.Warnf("found an invalid TMS ID/dd_progid: %s", cleanID) - continue + for tmsID := range sdEligible { + idType, uniqID, epID, _, _, extractErr := extractDDProgID(tmsID) + if extractErr != nil { + log.WithError(extractErr).Errorln("error extracting dd_progid") + continue + } + cleanID := fmt.Sprintf("%s%s%s", idType, padNumberWithZero(uniqID, 8), padNumberWithZero(epID, 4)) + if len(cleanID) < 14 { + log.Warnf("found an invalid TMS ID/dd_progid, expected length of exactly 14, got %d: %s\n", len(cleanID), cleanID) + continue + } + tmsIDs = append(tmsIDs, cleanID) } - tmsIDs = append(tmsIDs, cleanID[0:13]) - } - log.Infof("Requesting guide data for %d programs from Schedules Direct", len(tmsIDs)) + log.Infof("Requesting guide data for %d programs from Schedules Direct", len(tmsIDs)) + + allResponses := make([]schedulesdirect.ProgramInfo, 0) + + artworkMap := make(map[string][]schedulesdirect.ProgramArtwork) - allResponses := make([]GoSchedulesDirect.ProgramInfo, len(tmsIDs)) + chunks := chunkStringSlice(tmsIDs, 5000) - for _, chunk := range chunkStringSlice(tmsIDs, 5000) { - moreInfo, moreInfoErr := l.sd.GetProgramInfo(chunk) - if moreInfoErr != nil { - log.WithError(moreInfoErr).Errorln("Error when getting more program details from Schedules Direct") - return epgChannelMap, epgProgrammeMap, moreInfoErr + log.Infof("Making %d requests to Schedules Direct for program information, this might take a while", len(chunks)) + + for _, chunk := range chunks { + moreInfo, moreInfoErr := l.sd.GetProgramInfo(chunk) + if moreInfoErr != nil { + log.WithError(moreInfoErr).Errorln("Error when getting more program details from Schedules Direct") + return epgChannelMap, epgProgrammeMap, moreInfoErr + } + + log.Debugf("received %d responses for chunk", len(moreInfo)) + + allResponses = append(allResponses, moreInfo...) } - allResponses = append(allResponses, moreInfo...) - } + artworkTMSIDs := make([]string, 0) - log.Infoln("Got %d responses from SD", len(allResponses)) + for _, entry := range allResponses { + if entry.HasArtwork() { + artworkTMSIDs = append(artworkTMSIDs, entry.ProgramID) + } + } + + chunks = chunkStringSlice(artworkTMSIDs, 500) + + log.Infof("Making %d requests to Schedules Direct for artwork, this might take a while", len(chunks)) + + for _, chunk := range chunks { + artwork, artworkErr := l.sd.GetArtworkForProgramIDs(chunk) + if artworkErr != nil { + log.WithError(artworkErr).Errorln("Error when getting program artwork from Schedules Direct") + return epgChannelMap, epgProgrammeMap, artworkErr + } - for _, sdResponse := range allResponses { - mergedProgramme := MergeSchedulesDirectAndXMLTVProgramme(sdEligible[sdResponse.ProgramID], sdResponse) - haveAllInfo[mergedProgramme.Channel] = append(haveAllInfo[mergedProgramme.Channel], mergedProgramme) + for _, artworks := range artwork { + artworkMap[artworks.ProgramID] = append(artworkMap[artworks.ProgramID], *artworks.Artwork...) + } + } + + log.Debugf("Got %d responses from SD", len(allResponses)) + + for _, sdResponse := range allResponses { + programme := sdEligible[sdResponse.ProgramID] + mergedProgramme := MergeSchedulesDirectAndXMLTVProgramme(&programme, sdResponse, artworkMap[sdResponse.ProgramID]) + haveAllInfo[mergedProgramme.Channel] = append(haveAllInfo[mergedProgramme.Channel], *mergedProgramme) + } } for _, programmes := range haveAllInfo { @@ -479,7 +527,7 @@ func chunkStringSlice(sl []string, chunkSize int) [][]string { return divided } -func MergeSchedulesDirectAndXMLTVProgramme(programme xmltv.Programme, sdProgram GoSchedulesDirect.ProgramInfo) xmltv.Programme { +func MergeSchedulesDirectAndXMLTVProgramme(programme *xmltv.Programme, sdProgram schedulesdirect.ProgramInfo, artworks []schedulesdirect.ProgramArtwork) *xmltv.Programme { allTitles := make([]string, 0) @@ -501,13 +549,16 @@ func MergeSchedulesDirectAndXMLTVProgramme(programme xmltv.Programme, sdProgram allKeywords = append(allKeywords, keyword.Value) } - for keywordType, keywords := range sdProgram.Keywords { - log.Infoln("Adding keywords category", keywordType) + for _, keywords := range sdProgram.Keywords { for _, keyword := range keywords { allKeywords = append(allKeywords, keyword) } } + for _, keyword := range UniqueStrings(allKeywords) { + programme.Keywords = append(programme.Keywords, xmltv.CommonElement{Value: keyword}) + } + // FIXME: We should really be making sure that we passthrough languages. allDescriptions := make([]string, 0) @@ -517,7 +568,12 @@ func MergeSchedulesDirectAndXMLTVProgramme(programme xmltv.Programme, sdProgram for _, descriptions := range sdProgram.Descriptions { for _, description := range descriptions { - allDescriptions = append(allDescriptions, description.Description) + if description.Description100 != "" { + allDescriptions = append(allDescriptions, description.Description100) + } + if description.Description1000 != "" { + allDescriptions = append(allDescriptions, description.Description1000) + } } } @@ -525,10 +581,6 @@ func MergeSchedulesDirectAndXMLTVProgramme(programme xmltv.Programme, sdProgram programme.Descriptions = append(programme.Descriptions, xmltv.CommonElement{Value: description}) } - for _, keyword := range UniqueStrings(allKeywords) { - programme.Keywords = append(programme.Keywords, xmltv.CommonElement{Value: keyword}) - } - allRatings := make(map[string]string, 0) for _, rating := range programme.Ratings { @@ -543,36 +595,83 @@ func MergeSchedulesDirectAndXMLTVProgramme(programme xmltv.Programme, sdProgram programme.Ratings = append(programme.Ratings, xmltv.Rating{Value: rating, System: system}) } + for _, artwork := range artworks { + programme.Icons = append(programme.Icons, xmltv.Icon{ + Source: getImageURL(artwork.URI), + Width: artwork.Width, + Height: artwork.Height, + }) + } + hasXMLTVNS := false + ddProgID := "" for _, epNum := range programme.EpisodeNums { if epNum.System == "xmltv_ns" { hasXMLTVNS = true + } else if epNum.System == "dd_progid" { + ddProgID = epNum.Value } } if !hasXMLTVNS { - seasonNumber := 0 - episodeNumber := 0 + seasonNumber := int64(0) + episodeNumber := int64(0) + totalSeasons := int64(0) + totalEpisodes := int64(0) numbersFilled := false for _, meta := range sdProgram.Metadata { for _, metadata := range meta { - if metadata.Season != nil { - seasonNumber = *metadata.Season - 1 // SD metadata isnt 0 index + if metadata.Season > 0 { + seasonNumber = metadata.Season - 1 // SD metadata isnt 0 index + numbersFilled = true + } + if metadata.Episode > 0 { + episodeNumber = metadata.Episode - 1 + numbersFilled = true + } + if metadata.TotalEpisodes > 0 { + totalEpisodes = metadata.TotalEpisodes numbersFilled = true } - if metadata.Episode != nil { - episodeNumber = *metadata.Episode - 1 + if metadata.TotalSeasons > 0 { + totalSeasons = metadata.TotalSeasons numbersFilled = true } } } if numbersFilled { - // FIXME: There is currently no way to determine multipart episodes from SD. - // We could use the dd_progid to determine it though. - xmlTVNS := fmt.Sprintf("%d.%d.0/1", seasonNumber, episodeNumber) + seasonNumberStr := fmt.Sprintf("%d", seasonNumber) + if totalSeasons > 0 { + seasonNumberStr = fmt.Sprintf("%d/%d", seasonNumber, totalSeasons) + } + episodeNumberStr := fmt.Sprintf("%d", episodeNumber) + if totalEpisodes > 0 { + episodeNumberStr = fmt.Sprintf("%d/%d", episodeNumber, totalEpisodes) + } + + partNumber := 0 + totalParts := 0 + + if ddProgID != "" { + var extractErr error + _, _, _, partNumber, totalParts, extractErr = extractDDProgID(ddProgID) + if extractErr != nil { + panic(extractErr) + } + } + + partStr := "0" + if partNumber > 0 { + partStr = fmt.Sprintf("%d", partNumber) + if totalParts > 0 { + partStr = fmt.Sprintf("%d/%d", partNumber, totalParts) + } + } + + xmlTVNS := fmt.Sprintf("%s.%s.%s", seasonNumberStr, episodeNumberStr, partStr) programme.EpisodeNums = append(programme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmlTVNS}) } } @@ -635,6 +734,48 @@ func extractXMLTVNS(str string) (int, int, int, int, error) { return season, episode, currentPartNum, totalPartsNum, nil } +// extractDDProgID returns type, ID, episode ID, part number, total parts, error. +func extractDDProgID(progID string) (string, int, int, int, int, error) { + matches := ddProgIDRegex.FindAllStringSubmatch(progID, -1) + + if len(matches) == 0 { + return "", 0, 0, 0, 0, fmt.Errorf("invalid dd_progid: %s", progID) + } + + itemType := matches[0][1] + + itemID, itemIDErr := strconv.Atoi(matches[0][2]) + if itemIDErr != nil { + return itemType, 0, 0, 0, 0, itemIDErr + } + + specificID, specificIDErr := strconv.Atoi(matches[0][3]) + if specificIDErr != nil { + return itemType, itemID, 0, 0, 0, specificIDErr + } + + currentPartNum := 0 + totalPartsNum := 0 + + if len(matches[0]) > 2 && matches[0][4] != "" { + currentPart, currentPartErr := strconv.Atoi(matches[0][4]) + if currentPartErr != nil { + return itemType, itemID, specificID, 0, 0, currentPartErr + } + currentPartNum = currentPart + } + + if len(matches[0]) > 3 && matches[0][5] != "" { + totalParts, totalPartsErr := strconv.Atoi(matches[0][5]) + if totalPartsErr != nil { + return itemType, itemID, specificID, currentPartNum, 0, totalPartsErr + } + totalPartsNum = totalParts + } + + return itemType, itemID, specificID, currentPartNum, totalPartsNum, nil +} + func UniqueStrings(input []string) []string { u := make([]string, 0, len(input)) m := make(map[string]bool) @@ -648,3 +789,31 @@ func UniqueStrings(input []string) []string { return u } + +func getImageURL(imageURI string) string { + if strings.HasPrefix(imageURI, "https://s3.amazonaws.com") { + return imageURI + } + return fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", imageURI) +} + +func padNumberWithZero(value int, expectedLength int) string { + padded := fmt.Sprintf("%02d", value) + valLength := countDigits(value) + if valLength != expectedLength { + return fmt.Sprintf("%s%d", strings.Repeat("0", expectedLength-valLength), value) + } + return padded +} + +func countDigits(i int) int { + count := 0 + if i == 0 { + count = 1 + } + for i != 0 { + i /= 10 + count = count + 1 + } + return count +} From f41fff148dd675acb2e7c7d98a9171ea18ffabac Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 14:44:59 -0700 Subject: [PATCH 013/182] Update README --- README.md | 97 ++++++++++++++++++++++++++++++++----------------------- 1 file changed, 57 insertions(+), 40 deletions(-) diff --git a/README.md b/README.md index 56f2112..f4197b9 100644 --- a/README.md +++ b/README.md @@ -2,36 +2,61 @@ IPTV proxy for Plex Live written in Golang -# Setup - -> **See end of setup section for an important note about channel filtering** - -1) Go to the releases page and download the correct version for your Operating System -2) Mark the file as executable for non-windows platforms `chmod a+x ` -3) Rename the file to "telly" if desired; note that from here this readme will refer to "telly"; the file you downloaded is probably called "telly-linux-amd64.dms" or something like that. -**If you do not rename the file, then substitute references here to "telly" with the name of the file you've downloaded.** -**Under Windows, don't forget the `.exe`; i.e. `telly.exe`.** -4) Have the .m3u file on hand from your IPTV provider of choice -**Any command arguments can also be supplied as environment variables, for example --iptv.playlist can also be provided as the TELLY_IPTV_PLAYLIST environment variable** -5) Run `telly` with the `--iptv.playlist` commandline argument pointing to your .m3u file. (This can be a local file or a URL) For example: `./telly --iptv.playlist=/home/github/myiptv.m3u` -6) If you would like multiple streams/tuners use the `--iptv.streams` commandline option. Default is 1. When setting or changing this option, `plexmediaserver` will need to be completely **restarted**. -7) If you would like `telly` to attempt to the filter the m3u a bit, add the `--filter.regex` commandline option. If you would like to use your own regex, run `telly` with `--filter.regex=""`, for example `--filter.regex=".*UK.*"` -8) If `telly` tells you `[telly] [info] listening on ...` - great! Your .m3u file was successfully parsed and `telly` is running. Check below for how to add it into Plex. -9) If `telly` fails to run, check the error. If it's self explanatory, great. If you don't understand, feel free to open an issue and we'll help you out. As of telly v0.4 `sed` commands are no longer needed. Woop! -10) For your IPTV provider m3u, try using option `type=m3u_plus` and `output=ts`. - -> **Regex handling changed in 1.0. `filter.regex` has become blacklist which defaults to blocking everything. If you are not using a regex to filter your M3U file, you will need to add at a minimum `--regex.inclusive=true` to the command line. If you do not add this, telly will by default EXCLUDE everything in your M3U. The symptom here is typically telly seeming to start up just fine but reporting 0 channels.** - -# Adding it into Plex - -1) Once `telly` is running, you can add it to Plex. **Plex Live requires Plex Pass at the time of writing** -2) Navigate to `app.plex.tv` and make sure you're logged in. Go to Settings -> Server -> Live TV & DVR -3) Click 'Setup' or 'Add'. Plex won't find your device, so press the text to add it manually - input `localhost:6077` (or whatever port you're using - you can change it using the `-listen` commandline argument, i.e. `-listen localhost:12345`) -4) Plex will find your device (in some cases it continues to load but the continue button becomes orange, i.e. clickable. Click it) - select the country in the bottom left and ensure Plex has found the channels. Proceed. -5) Once you get to the channel listing, `telly` currently __doesn't__ have any idea of EPG data so it __starts the channel numbers at 10000 to avoid complications__ with selecting channels at this stage. EPG APIs will come in the future, but for now you'll have to manually match up what `telly` is telling Plex to the actual channel numbers. For UK folk, `Sky HD` is the best option I've found. -6) Once you've matched up all the channels, hit next and Plex will start downloading necessary EPG data. -7) Once that is done, you might need to restart Plex so the telly tuner is not marked as dead. -8) You're done! Enjoy using `telly`. :-) +# Configuration + +Here's an example configuration file. It should be placed in `/etc/telly/telly.config.toml` or `$HOME/.telly/telly.config.toml` or `telly.config.toml` in the directory that telly is running from. + +```toml +[Discovery] + Device-Auth = "telly123" + Device-ID = 12345678 + Device-UUID = "" + Device-Firmware-Name = "hdhomeruntc_atsc" + Device-Firmware-Version = "20150826" + Device-Friendly-Name = "telly" + Device-Manufacturer = "Silicondust" + Device-Model-Number = "HDTC-2US" + SSDP = true + +[IPTV] + Streams = 1 + Starting-Channel = 10000 + XMLTV-Channels = true + +[Log] + Level = "info" + Requests = true + +[Web] + Base-Address = "0.0.0.0:6077" + Listen-Address = "0.0.0.0:6077" + +[SchedulesDirect] + Username = "" + Password = "" + +[[Source]] + Name = "" + Provider = "Vaders" + Username = "" + Password = "" + Filter = "Sports|Premium Movies|United States.*|USA" + FilterKey = "tvg-name" // FilterKey normally defaults to whatever the provider file says is best, otherwise you must set this. + FilterRaw = false // FilterRaw will run your regex on the entire line instead of just specific keys. + Sort = "group-title" // Sort will alphabetically sort your channels by the M3U key provided + +[[Source]] + Name = "" + Provider = "IPTV-EPG" + Username = "M3U-Identifier" + Password = "XML-Identifier" + + +[[Source]] + Provider = "Custom" + M3U = "http://myprovider.com/playlist.m3u" + EPG = "http://myprovider.com/epg.xml" +``` # Docker @@ -41,9 +66,7 @@ docker run -d \ --name='telly' \ --net='bridge' \ -e TZ="Europe/Amsterdam" \ - -e 'TELLY_IPTV_PLAYLIST'='/home/github/myiptv.m3u' \ - -e TELLY_IPTV_STREAMS=1 \ - -e TELLY_FILTER_REGEX='.*UK.*' \ + -e 'TELLY_CONFIG_FILE'='/telly.config.toml' \ -p '6077:6077/tcp' \ -v '/tmp/telly':'/tmp':'rw' \ tellytv/telly --listen.base-address=localhost:6077 @@ -57,17 +80,11 @@ telly: - "6077:6077" environment: - TZ=Europe/Amsterdam - - TELLY_IPTV_PLAYLIST=/home/github/myiptv.m3u - - TELLY_FILTER_REGEX='.*UK.*' - - TELLY_WEB_LISTEN_ADDRESS=telly:6077 - - TELLY_IPTV_STREAMS=1 - - TELLY_DISCOVERY_FRIENDLYNAME=Tuner1 - - TELLY_DISCOVERY_DEVICEID=12345678 + - TELLY_CONFIG_FILE=/telly.config.toml command: -base=telly:6077 restart: unless-stopped ``` - # Troubleshooting Please free to open an issue if you run into any issues at all, I'll be more than happy to help. From 0c8d54609233f1cd7296acd4f11bb6657dd92d8b Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 14:47:53 -0700 Subject: [PATCH 014/182] Update Gopkg.lock --- Gopkg.lock | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Gopkg.lock b/Gopkg.lock index 3209f48..8499add 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -223,6 +223,14 @@ revision = "907c19d40d9a6c9bb55f040ff4ae45271a4754b9" version = "v1.1.0" +[[projects]] + branch = "master" + digest = "1:2f6be3c7ff8cc65d5f6b35c2acd928aed1386fc31dc11483045b393660698244" + name = "github.com/tellytv/go.schedulesdirect" + packages = ["."] + pruneopts = "UT" + revision = "3d6704d3b108deaffd476ad2f27003dc38bf775d" + [[projects]] digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" name = "github.com/ugorji/go" @@ -323,6 +331,7 @@ "github.com/sirupsen/logrus", "github.com/spf13/pflag", "github.com/spf13/viper", + "github.com/tellytv/go.schedulesdirect", "golang.org/x/net/html/charset", ] solver-name = "gps-cdcl" From 02c02065a07adb8c02450804c47e9195fe6e9998 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 15:16:48 -0700 Subject: [PATCH 015/182] Fix XMLTV tests --- internal/xmltv/xmltv_test.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/internal/xmltv/xmltv_test.go b/internal/xmltv/xmltv_test.go index f2eec7c..4823566 100644 --- a/internal/xmltv/xmltv_test.go +++ b/internal/xmltv/xmltv_test.go @@ -60,7 +60,7 @@ func TestDecode(t *testing.T) { }, Icons: []Icon{ Icon{ - Source: `file://C:\Perl\site/share/internal/xmltv/icons/KERA.gif`, + Source: `file://C:\Perl\site/share/xmltv/icons/KERA.gif`, }, }, } @@ -69,9 +69,10 @@ func TestDecode(t *testing.T) { } loc := time.FixedZone("", -6*60*60) + date := time.Date(2008, 07, 11, 0, 0, 0, 0, time.UTC) pr := Programme{ ID: "someId", - Date: "20080711", + Date: Date(date), Channel: "I10436.labs.zap2it.com", Start: &Time{time.Date(2008, 07, 15, 0, 30, 0, 0, loc)}, Stop: &Time{time.Date(2008, 07, 15, 1, 0, 0, 0, loc)}, From 7b34d39314f21a4b496895a3b6222f1a5b49fe23 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 15:29:52 -0700 Subject: [PATCH 016/182] Fix example.xml path --- internal/xmltv/xmltv_test.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/internal/xmltv/xmltv_test.go b/internal/xmltv/xmltv_test.go index 4823566..b3767d5 100644 --- a/internal/xmltv/xmltv_test.go +++ b/internal/xmltv/xmltv_test.go @@ -17,9 +17,14 @@ func dummyReader(charset string, input io.Reader) (io.Reader, error) { } func TestDecode(t *testing.T) { + dir, err := os.Getwd() + if err != nil { + t.Fatal(err) + } + // Example downloaded from http://wiki.xmltv.org/index.php/internal/xmltvFormat // One may check it with `xmllint --noout --dtdvalid xmltv.dtd example.xml` - f, err := os.Open("example.xml") + f, err := os.Open(fmt.Sprintf("%s/example.xml", dir)) if err != nil { t.Fatal(err) } From 2c9f0bd3c74ecfe1b5fd6ece78255037174ec920 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 15:30:02 -0700 Subject: [PATCH 017/182] Update README.md --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index f4197b9..4969aaf 100644 --- a/README.md +++ b/README.md @@ -41,9 +41,9 @@ Here's an example configuration file. It should be placed in `/etc/telly/telly.c Username = "" Password = "" Filter = "Sports|Premium Movies|United States.*|USA" - FilterKey = "tvg-name" // FilterKey normally defaults to whatever the provider file says is best, otherwise you must set this. - FilterRaw = false // FilterRaw will run your regex on the entire line instead of just specific keys. - Sort = "group-title" // Sort will alphabetically sort your channels by the M3U key provided + FilterKey = "tvg-name" # FilterKey normally defaults to whatever the provider file says is best, otherwise you must set this. + FilterRaw = false # FilterRaw will run your regex on the entire line instead of just specific keys. + Sort = "group-title" # Sort will alphabetically sort your channels by the M3U key provided [[Source]] Name = "" From 39768616c05f3c3aa0d63a175dfb53ae4c27cda7 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 19 Aug 2018 15:32:02 -0700 Subject: [PATCH 018/182] Allow xmltv/example.xml into Git --- .gitignore | 2 +- internal/xmltv/example.xml | 182 +++++++++++++++++++++++++++++++++++++ 2 files changed, 183 insertions(+), 1 deletion(-) create mode 100644 internal/xmltv/example.xml diff --git a/.gitignore b/.gitignore index 05fc00e..9143f10 100644 --- a/.gitignore +++ b/.gitignore @@ -4,7 +4,7 @@ telly .DS_Store /.GOPATH /bin -*.xml +/*.xml vendor/ /.build /.release diff --git a/internal/xmltv/example.xml b/internal/xmltv/example.xml new file mode 100644 index 0000000..f71df21 --- /dev/null +++ b/internal/xmltv/example.xml @@ -0,0 +1,182 @@ + + + + + + 13 KERA + 13 KERA TX42822:- + 13 + 13 KERA fcc + KERA + KERA + PBS Affiliate + + + + 11 KTVT + 11 KTVT TX42822:- + 11 + 11 KTVT fcc + KTVT + KTVT + CBS Affiliate + + + + NOW on PBS + Jordan's Queen Rania has made job creation a priority to help curb the staggering unemployment rates among youths in the Middle East. + 20080711 + Newsmagazine + Interview + Public affairs + Series + EP01006886.0028 + 427 + + + + + + Mystery! + Foyle's War, Series IV: Bleak Midwinter + Foyle investigates an explosion at a munitions factory, which he comes to believe may have been premeditated. + 20070701 + Anthology + Mystery + Series + EP00003026.0665 + 2705 + + + + + + Mystery! + Foyle's War, Series IV: Casualties of War + The murder of a prominent scientist may have been due to a gambling debt. + 20070708 + Anthology + Mystery + Series + EP00003026.0666 + 2706 + + + + + + BBC World News + International issues. + News + Series + SH00315789.0000 + + + + + Sit and Be Fit + 20070924 + Exercise + Series + EP00003847.0074 + 901 + + + + + + The Early Show + Republican candidate John McCain; premiere of the film "The Dark Knight." + 20080715 + Talk + News + Series + EP00337003.2361 + + + + + Rachael Ray + Actresses Kim Raver, Brooke Shields and Lindsay Price ("Lipstick Jungle"); women in their 40s tell why they got breast implants; a 30-minute meal. + + Rachael Ray + + 20080306 + Talk + Series + EP00847333.0303 + 2119 + + + + + + The Price Is Right + Contestants bid for prizes then compete for fabulous showcases. + + Bart Eskander + Roger Dobkowitz + Drew Carey + + Game show + Series + SH00004372.0000 + + + + TV-G + + + + Jeopardy! + + Alex Trebek + + 20080715 + Game show + Series + EP00002348.1700 + 5507 + + + TV-G + + + + The Young and the Restless + Sabrina Offers Victoria a Truce + Jeff thinks Kyon stole the face cream; Nikki asks Nick to give David a chance; Amber begs Adrian to go to Australia. + + Peter Bergman + Eric Braeden + Jeanne Cooper + Melody Thomas Scott + + 20080715 + Soap + Series + EP00004422.1359 + 8937 + + + + TV-14 + + + From 66fb27756e99c5f9bda28ffa1ecf8b7858a17a12 Mon Sep 17 00:00:00 2001 From: Guy Spronck Date: Mon, 20 Aug 2018 20:19:48 +0200 Subject: [PATCH 019/182] Add option to ignore-epg-icons under misc --- lineup.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/lineup.go b/lineup.go index 1d27dd7..224405a 100644 --- a/lineup.go +++ b/lineup.go @@ -248,6 +248,9 @@ func (l *lineup) processProviderChannel(channel *providers.ProviderChannel, prog } if channel.Logo != "" && channel.EPGChannel != nil && !containsIcon(channel.EPGChannel.Icons, channel.Logo) { + if viper.GetBool("misc.ignore-epg-icons") { + channel.EPGChannel.Icons = nil + } channel.EPGChannel.Icons = append(channel.EPGChannel.Icons, xmltv.Icon{Source: channel.Logo}) } From 309792d7b5976a9689d2386c43961ead77cc11ec Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 11:31:06 -0700 Subject: [PATCH 020/182] Only initialize Schedules Direct if configured. Fixes #149 --- VERSION | 2 +- lineup.go | 12 +++++++----- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/VERSION b/VERSION index 9084fa2..238afc2 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.1.0 +1.1.0.1 diff --git a/lineup.go b/lineup.go index 224405a..ecad8fd 100644 --- a/lineup.go +++ b/lineup.go @@ -100,12 +100,14 @@ func newLineup() *lineup { channels: make(map[int]hdHomeRunLineupItem), } - sdClient, sdClientErr := schedulesdirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) - if sdClientErr != nil { - log.WithError(sdClientErr).Panicln("error setting up schedules direct client") - } + if viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") { + sdClient, sdClientErr := schedulesdirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) + if sdClientErr != nil { + log.WithError(sdClientErr).Panicln("error setting up schedules direct client") + } - lineup.sd = sdClient + lineup.sd = sdClient + } for _, cfg := range cfgs { provider, providerErr := cfg.GetProvider() From 107d30a0e53372dfda340bd5c555a93bb1443a4b Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Mon, 20 Aug 2018 22:08:36 -0400 Subject: [PATCH 021/182] FAQs Add remarks to address questions asked repeatedly on discord. --- README.md | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index 4969aaf..27f0233 100644 --- a/README.md +++ b/README.md @@ -4,7 +4,7 @@ IPTV proxy for Plex Live written in Golang # Configuration -Here's an example configuration file. It should be placed in `/etc/telly/telly.config.toml` or `$HOME/.telly/telly.config.toml` or `telly.config.toml` in the directory that telly is running from. +Here's an example configuration file. You will need to create this file. It should be placed in `/etc/telly/telly.config.toml` or `$HOME/.telly/telly.config.toml` or `telly.config.toml` in the directory that telly is running from. ```toml [Discovery] @@ -57,6 +57,11 @@ Here's an example configuration file. It should be placed in `/etc/telly/telly.c M3U = "http://myprovider.com/playlist.m3u" EPG = "http://myprovider.com/epg.xml" ``` +You only need one source; the ones you are not using should be commented out or deleted. The filter-related keys can be used with any of the sources. + +If you do not have a Schedules Direct account, that section can be removed or left blank. + +Set listen- and base-address to the IP address of the machine running telly. # Docker From a2fd7425ff1d95632b5cc2d543236243c7309916 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 20:50:37 -0700 Subject: [PATCH 022/182] Fixes for bad providers & gzip --- lineup.go | 12 +++++++++++- 1 file changed, 11 insertions(+), 1 deletion(-) diff --git a/lineup.go b/lineup.go index ecad8fd..94de56f 100644 --- a/lineup.go +++ b/lineup.go @@ -467,12 +467,22 @@ func getFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { if strings.HasPrefix(strings.ToLower(path), "http") { + transport = "http" + + req, reqErr := http.NewRequest("GET", path, nil) + if reqErr != nil { + return nil, transport, reqErr + } + + // For whatever reason, some providers only allow access from a "real" User-Agent. + req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36") + resp, err := http.Get(path) if err != nil { return nil, transport, err } - if strings.HasSuffix(strings.ToLower(path), ".gz") { + if strings.HasSuffix(strings.ToLower(path), ".gz") || resp.Header.Get("Content-Type") == "application/x-gzip" { log.Infof("File (%s) is gzipp'ed, ungzipping now, this might take a while", path) gz, gzErr := gzip.NewReader(resp.Body) if gzErr != nil { From e74ee7648e20afcbff16451fc1996c69a25fae5c Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 20:50:58 -0700 Subject: [PATCH 023/182] Temporary fix for artwork nil issues --- lineup.go | 3 +++ 1 file changed, 3 insertions(+) diff --git a/lineup.go b/lineup.go index 94de56f..fca645f 100644 --- a/lineup.go +++ b/lineup.go @@ -404,6 +404,9 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s } for _, artworks := range artwork { + if artworks.ProgramID == "" || artworks.Artwork == nil { + continue + } artworkMap[artworks.ProgramID] = append(artworkMap[artworks.ProgramID], *artworks.Artwork...) } } From b407718e4497e1d282ed0465e92ce82d4e776ea9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 21:10:19 -0700 Subject: [PATCH 024/182] Change username/password replacement tokens --- main.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/main.go b/main.go index 66fb61f..2e4d6f2 100644 --- a/main.go +++ b/main.go @@ -40,9 +40,9 @@ var ( stringSafer = func(input string) string { ret := input if strings.HasPrefix(input, "username=") { - ret = "username=hunter1" + ret = "username=REDACTED" } else if strings.HasPrefix(input, "password=") { - ret = "password=hunter2" + ret = "password=REDACTED" } else if strings.HasPrefix(input, "token=") { ret = "token=bm90Zm9yeW91" // "notforyou" } From 8f377617396664774b9f1496194c425270f87bca Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 21:10:37 -0700 Subject: [PATCH 025/182] Dont panic on empty tags --- lineup.go | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/lineup.go b/lineup.go index fca645f..05f0d7a 100644 --- a/lineup.go +++ b/lineup.go @@ -279,15 +279,12 @@ func (l *lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool filterKey := provider.RegexKey() if config.FilterKey != "" { - if key, ok := track.Tags[config.FilterKey]; key != "" && ok { - filterKey = config.FilterKey - } else { - log.Panicf("the provided filter key (%s) does not exist or is blank", config.FilterKey) - } + filterKey = config.FilterKey } - if _, ok := track.Tags[filterKey]; !ok { - log.Panicf("Provided filter key %s doesn't exist in M3U tags", filterKey) + if key, ok := track.Tags[filterKey]; key != "" && !ok { + log.Warnf("the provided filter key (%s) does not exist or is blank, skipping track: %s", config.FilterKey, track.Raw) + return false } log.Debugf("Checking if filter (%s) matches string %s", config.Filter, track.Tags[filterKey]) From 9f22c3a665dfc8f93059ed05242e6adb121b28de Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 21:25:27 -0700 Subject: [PATCH 026/182] Add Iris as a supported provider --- internal/providers/iris.go | 77 ++++++++++++++++++++++++++++++++++++++ internal/providers/main.go | 2 + 2 files changed, 79 insertions(+) diff --git a/internal/providers/iris.go b/internal/providers/iris.go index 01d10ec..c05814a 100644 --- a/internal/providers/iris.go +++ b/internal/providers/iris.go @@ -1,4 +1,81 @@ package providers +import ( + "fmt" + "strings" + + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" +) + // http://irislinks.net:83/get.php?username=username&password=password&type=m3uplus&output=ts // http://irislinks.net:83/xmltv.php?username=username&password=password + +type iris struct { + BaseConfig Configuration +} + +func newIris(config *Configuration) (Provider, error) { + return &iris{*config}, nil +} + +func (i *iris) Name() string { + return "Iris" +} + +func (i *iris) PlaylistURL() string { + return fmt.Sprintf("http://irislinks.net:83/get.php?username=%s&password=%s&type=m3u_plus&output=ts", i.BaseConfig.Username, i.BaseConfig.Password) +} + +func (i *iris) EPGURL() string { + return fmt.Sprintf("http://irislinks.net:83/xmltv.php?username=%s&password=%s", i.BaseConfig.Username, i.BaseConfig.Password) +} + +// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. +func (i *iris) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { + nameVal := track.Name + if i.BaseConfig.NameKey != "" { + nameVal = track.Tags[i.BaseConfig.NameKey] + } + + logoVal := track.Tags["tvg-logo"] + if i.BaseConfig.LogoKey != "" { + logoVal = track.Tags[i.BaseConfig.LogoKey] + } + + pChannel := &ProviderChannel{ + Name: nameVal, + Logo: logoVal, + Number: 0, + StreamURL: track.URI, + StreamID: 0, + HD: strings.Contains(strings.ToLower(track.Name), "hd"), + StreamFormat: "Unknown", + Track: track, + OnDemand: false, + } + + epgVal := track.Tags["tvg-id"] + if i.BaseConfig.EPGMatchKey != "" { + epgVal = track.Tags[i.BaseConfig.EPGMatchKey] + } + + if xmlChan, ok := channelMap[epgVal]; ok { + pChannel.EPGMatch = epgVal + pChannel.EPGChannel = &xmlChan + } + + return pChannel, nil +} + +func (i *iris) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { + return &programme +} + +func (i *iris) Configuration() Configuration { + return i.BaseConfig +} + +func (i *iris) RegexKey() string { + return "group-title" +} diff --git a/internal/providers/main.go b/internal/providers/main.go index 5931408..122877d 100644 --- a/internal/providers/main.go +++ b/internal/providers/main.go @@ -49,6 +49,8 @@ func (i *Configuration) GetProvider() (Provider, error) { return newVaders(i) case "iptv-epg", "iptvepg": return newIPTVEPG(i) + case "iris", "iristv": + return newIris(i) default: return newCustomProvider(i) } From f2c1a81c4f5c32297416799dcf4835a6352cbcd5 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 21:34:24 -0700 Subject: [PATCH 027/182] Lowercase tags --- internal/m3uplus/main.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/m3uplus/main.go b/internal/m3uplus/main.go index 43d2606..712e539 100644 --- a/internal/m3uplus/main.go +++ b/internal/m3uplus/main.go @@ -126,7 +126,7 @@ func decodeInfoLine(line string) (float64, string, map[string]string) { if val == "" { // If empty string find a number in [3] val = match[3] } - keyMap[match[1]] = val + keyMap[strings.ToLower(match[1])] = val } return durationFloat, title, keyMap From 6d4f90224080ec3a6e86e4e1672a9331a78171a5 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 21:34:57 -0700 Subject: [PATCH 028/182] Add Area51 as a provider --- internal/providers/area51.go | 81 ++++++++++++++++++++++++++++++++++++ internal/providers/main.go | 2 + 2 files changed, 83 insertions(+) create mode 100644 internal/providers/area51.go diff --git a/internal/providers/area51.go b/internal/providers/area51.go new file mode 100644 index 0000000..e2c2f87 --- /dev/null +++ b/internal/providers/area51.go @@ -0,0 +1,81 @@ +package providers + +import ( + "fmt" + "strings" + + m3u "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" +) + +// http://iptv-area-51.tv:2095/get.php?username=username&password=password&type=m3uplus&output=ts +// http://iptv-area-51.tv:2095/xmltv.php?username=username&password=password + +type area51 struct { + BaseConfig Configuration +} + +func newArea51(config *Configuration) (Provider, error) { + return &area51{*config}, nil +} + +func (i *area51) Name() string { + return "Area51" +} + +func (i *area51) PlaylistURL() string { + return fmt.Sprintf("http://iptv-area-51.tv:2095/get.php?username=%s&password=%s&type=m3u_plus&output=ts", i.BaseConfig.Username, i.BaseConfig.Password) +} + +func (i *area51) EPGURL() string { + return fmt.Sprintf("http://iptv-area-51.tv:2095/xmltv.php?username=%s&password=%s", i.BaseConfig.Username, i.BaseConfig.Password) +} + +// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. +func (i *area51) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { + nameVal := track.Name + if i.BaseConfig.NameKey != "" { + nameVal = track.Tags[i.BaseConfig.NameKey] + } + + logoVal := track.Tags["tvg-logo"] + if i.BaseConfig.LogoKey != "" { + logoVal = track.Tags[i.BaseConfig.LogoKey] + } + + pChannel := &ProviderChannel{ + Name: nameVal, + Logo: logoVal, + Number: 0, + StreamURL: track.URI, + StreamID: 0, + HD: strings.Contains(strings.ToLower(track.Name), "hd"), + StreamFormat: "Unknown", + Track: track, + OnDemand: false, + } + + epgVal := track.Tags["tvg-id"] + if i.BaseConfig.EPGMatchKey != "" { + epgVal = track.Tags[i.BaseConfig.EPGMatchKey] + } + + if xmlChan, ok := channelMap[epgVal]; ok { + pChannel.EPGMatch = epgVal + pChannel.EPGChannel = &xmlChan + } + + return pChannel, nil +} + +func (i *area51) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { + return &programme +} + +func (i *area51) Configuration() Configuration { + return i.BaseConfig +} + +func (i *area51) RegexKey() string { + return "group-title" +} diff --git a/internal/providers/main.go b/internal/providers/main.go index 122877d..3bddfbc 100644 --- a/internal/providers/main.go +++ b/internal/providers/main.go @@ -51,6 +51,8 @@ func (i *Configuration) GetProvider() (Provider, error) { return newIPTVEPG(i) case "iris", "iristv": return newIris(i) + case "area51": + return newArea51(i) default: return newCustomProvider(i) } From a4d0dcb8ca71bc11ad7dab24705894d2a30616c2 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 23:02:57 -0700 Subject: [PATCH 029/182] Support including only specific channels --- internal/providers/main.go | 3 +++ lineup.go | 15 ++++++++++++++- 2 files changed, 17 insertions(+), 1 deletion(-) diff --git a/internal/providers/main.go b/internal/providers/main.go index 3bddfbc..41c199b 100644 --- a/internal/providers/main.go +++ b/internal/providers/main.go @@ -35,6 +35,9 @@ type Configuration struct { Favorites []string FavoriteTag string + IncludeOnly []string + IncludeOnlyTag string + CacheFiles bool NameKey string diff --git a/lineup.go b/lineup.go index 05f0d7a..275432c 100644 --- a/lineup.go +++ b/lineup.go @@ -261,10 +261,14 @@ func (l *lineup) processProviderChannel(channel *providers.ProviderChannel, prog func (l *lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool { config := provider.Configuration() - if config.Filter == "" { + if config.Filter == "" && len(config.IncludeOnly) == 0 { return true } + if v, ok := track.Tags[config.IncludeOnlyTag]; len(config.IncludeOnly) > 0 && ok { + return contains(config.IncludeOnly, v) + } + filterRegex, regexErr := regexp.Compile(config.Filter) if regexErr != nil { log.WithError(regexErr).Panicln("your regex is invalid") @@ -832,3 +836,12 @@ func countDigits(i int) int { } return count } + +func contains(s []string, e string) bool { + for _, ss := range s { + if e == ss { + return true + } + } + return false +} From d824e2cde8bffe3ad1ffe3e3a995c85238a2c5f3 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 23:03:46 -0700 Subject: [PATCH 030/182] Possibly fix some weird behavior --- internal/providers/vaders.go | 4 +++- internal/xmltv/xmltv.go | 2 +- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go index 40d705b..9dcac0b 100644 --- a/internal/providers/vaders.go +++ b/internal/providers/vaders.go @@ -123,7 +123,9 @@ func (v *vader) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { programme.Titles[idx].Value = strings.Replace(title.Value, " [New!]", "", -1) } - programme.New = xmltv.ElementPresent(isNew) + if isNew { + programme.New = xmltv.ElementPresent(true) + } return &programme } diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 1cf2ea6..7e957bd 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -142,7 +142,7 @@ type Programme struct { PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` - New ElementPresent `xml:"new" json:"new,omitempty"` + New ElementPresent `xml:"new>placeholder" json:"new,omitempty"` Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` From 54671b48c2749594d9d53323dbc02260f46ccbbe Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 23:04:06 -0700 Subject: [PATCH 031/182] Maybe fix TV shows for Plex? --- lineup.go | 8 +++++++- 1 file changed, 7 insertions(+), 1 deletion(-) diff --git a/lineup.go b/lineup.go index 275432c..5108738 100644 --- a/lineup.go +++ b/lineup.go @@ -423,7 +423,13 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s for _, programmes := range haveAllInfo { for _, programme := range programmes { - epgProgrammeMap[programme.Channel] = append(epgProgrammeMap[programme.Channel], *provider.ProcessProgramme(programme)) + processedProgram := *provider.ProcessProgramme(programme) + if processedProgram.Start != nil { + if !processedProgram.Start.Time.IsZero() { + processedProgram.EpisodeNums = append(processedProgram.EpisodeNums, xmltv.EpisodeNum{System: "original-air-date", Value: processedProgram.Start.Time.Format("2006-01-02 15:04:05")}) + } + } + epgProgrammeMap[programme.Channel] = append(epgProgrammeMap[programme.Channel], processedProgram) } } From ba9beacef09b26f5f6785599da92975ea1b95977 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 23:04:23 -0700 Subject: [PATCH 032/182] Cleanup .promu.yml, limit to certain platforms for crossbuild --- .promu.yml | 34 +++++++++++++++++++++++----------- 1 file changed, 23 insertions(+), 11 deletions(-) diff --git a/.promu.yml b/.promu.yml index e3986e5..eeb4831 100644 --- a/.promu.yml +++ b/.promu.yml @@ -1,14 +1,26 @@ repository: - path: github.com/tellytv/telly + path: github.com/tellytv/telly build: - flags: -a -tags netgo - ldflags: | - -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildUser={{user}}@{{host}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildDate={{date "20060102-15:04:05"}} + flags: -a -tags netgo + ldflags: | + -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildUser={{user}}@{{host}} + -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildDate={{date "20060102-15:04:05"}} tarball: - files: - - LICENSE - - NOTICE + files: + - LICENSE + - NOTICE +crossbuild: + platforms: + - linux/amd64 + - linux/386 + - darwin/amd64 + - darwin/386 + - windows/amd64 + - windows/386 + - freebsd/amd64 + - freebsd/386 + - linux/arm + - linux/arm64 From 51b3215193c5f593b10414ea1f93fafb21eae0db Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 23:04:34 -0700 Subject: [PATCH 033/182] Update Gopkg.toml --- Gopkg.toml | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Gopkg.toml b/Gopkg.toml index 546090b..0ba7f07 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -49,6 +49,10 @@ name = "github.com/sirupsen/logrus" version = "1.0.6" +[[constraint]] + name = "github.com/tellytv/go.schedulesdirect" + version = "master" + [prune] go-tests = true unused-packages = true From fd0178908564edf5c5c36051982e6df4e9d49eb9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 20 Aug 2018 23:04:48 -0700 Subject: [PATCH 034/182] Bump version --- VERSION | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/VERSION b/VERSION index 238afc2..a3fdef3 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.1.0.1 +1.1.0.2 From 906a1cf162c5f46bbccf7dec1a93eff0784d465d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 21 Aug 2018 00:02:47 -0700 Subject: [PATCH 035/182] Fix for XMLTV tag --- internal/providers/vaders.go | 3 ++- internal/xmltv/xmltv.go | 7 +++++-- 2 files changed, 7 insertions(+), 3 deletions(-) diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go index 9dcac0b..4344724 100644 --- a/internal/providers/vaders.go +++ b/internal/providers/vaders.go @@ -124,7 +124,8 @@ func (v *vader) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { } if isNew { - programme.New = xmltv.ElementPresent(true) + elm := xmltv.ElementPresent(true) + programme.New = &elm } return &programme diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 7e957bd..e8a29a4 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -142,7 +142,7 @@ type Programme struct { PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` - New ElementPresent `xml:"new>placeholder" json:"new,omitempty"` + New *ElementPresent `xml:"new" json:"new,omitempty"` Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` @@ -168,7 +168,10 @@ type ElementPresent bool // MarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 func (c *ElementPresent) MarshalXML(e *xml.Encoder, start xml.StartElement) error { - return e.EncodeElement(nil, start) + if c == nil { + return e.EncodeElement(nil, start) + } + return e.EncodeElement("", start) } // UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 From 85a53b438262fa3f58abf4fc95c90620ffb32d9b Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 21 Aug 2018 00:03:11 -0700 Subject: [PATCH 036/182] Improve logic around adding original-air-date --- lineup.go | 23 ++++++++++++++++++++--- 1 file changed, 20 insertions(+), 3 deletions(-) diff --git a/lineup.go b/lineup.go index 5108738..8030c12 100644 --- a/lineup.go +++ b/lineup.go @@ -11,6 +11,7 @@ import ( "sort" "strconv" "strings" + "time" "github.com/spf13/viper" "github.com/tellytv/go.schedulesdirect" @@ -424,9 +425,25 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s for _, programmes := range haveAllInfo { for _, programme := range programmes { processedProgram := *provider.ProcessProgramme(programme) - if processedProgram.Start != nil { - if !processedProgram.Start.Time.IsZero() { - processedProgram.EpisodeNums = append(processedProgram.EpisodeNums, xmltv.EpisodeNum{System: "original-air-date", Value: processedProgram.Start.Time.Format("2006-01-02 15:04:05")}) + hasXMLTV := false + itemType := "" + for _, epNum := range processedProgram.EpisodeNums { + if epNum.System == "dd_progid" { + idType, _, _, _, _, extractErr := extractDDProgID(epNum.Value) + if extractErr != nil { + log.WithError(extractErr).Errorln("error extracting dd_progid") + continue + } + itemType = idType + } + if epNum.System == "xmltv_ns" { + hasXMLTV = true + } + } + if (itemType == "SH" || itemType == "EP") && !hasXMLTV { + t := time.Time(processedProgram.Date) + if !t.IsZero() { + processedProgram.EpisodeNums = append(processedProgram.EpisodeNums, xmltv.EpisodeNum{System: "original-air-date", Value: t.Format("2006-01-02 15:04:05")}) } } epgProgrammeMap[programme.Channel] = append(epgProgrammeMap[programme.Channel], processedProgram) From bf7b5824baf8916ebf32a7f0fde40aa771a52a8f Mon Sep 17 00:00:00 2001 From: Guy Spronck Date: Tue, 21 Aug 2018 18:40:17 +0200 Subject: [PATCH 037/182] Add CORS headers for Angular --- routes.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/routes.go b/routes.go index 203dcef..0fa958f 100644 --- a/routes.go +++ b/routes.go @@ -9,6 +9,7 @@ import ( "strings" "time" + "github.com/gin-contrib/cors" "github.com/gin-gonic/gin" ssdp "github.com/koron/go-ssdp" "github.com/sirupsen/logrus" @@ -30,6 +31,7 @@ func serve(lineup *lineup) { } router := gin.New() + router.Use(cors.Default()) router.Use(gin.Recovery()) if viper.GetBool("log.logrequests") { @@ -88,9 +90,11 @@ func serve(lineup *lineup) { } } - log.Infof("telly is live and on the air!") + log.Infof("telly is live and on the air! NOW WITH CORS") log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) + + if err := router.Run(viper.GetString("web.listen-address")); err != nil { log.WithError(err).Panicln("Error starting up web server") } From 8ee70559811c333548752ea54171ab609eef9b99 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 21 Aug 2018 18:24:56 -0700 Subject: [PATCH 038/182] Add frontend --- .gitmodules | 3 +++ a_main-packr.go | 18 ++++++++++++++++++ frontend | 1 + routes.go | 5 +++++ 4 files changed, 27 insertions(+) create mode 100644 .gitmodules create mode 100644 a_main-packr.go create mode 160000 frontend diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..c601d1c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "frontend"] + path = frontend + url = https://github.com/tellytv/frontend.git diff --git a/a_main-packr.go b/a_main-packr.go new file mode 100644 index 0000000..3d00397 --- /dev/null +++ b/a_main-packr.go @@ -0,0 +1,18 @@ +// Code generated by github.com/gobuffalo/packr. DO NOT EDIT. + +package main + +import "github.com/gobuffalo/packr" + +// You can use the "packr clean" command to clean up this, +// and any other packr generated files. +func init() { + packr.PackJSONBytes("./frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"H4sIAAAAAAAA/+xU3W7bNhi951Mc5KoFVC8Ntq7YVRmLtohJpEDRzXwpS7TFTCYNkW6QPf1A2WmR7RGaK0Hf3/nO+YjT+cl8eAxf7ha/LX4nFddk6U/Pkz0MEe+697i7/fjrh7vbj5+RG2cD6nMY/m4n842Q2kxHG4L1DjZgMJPZPeMwtS6aPsN+MgZ+j25op4PJED1a94yTmYJ38LvYWmfdAS06f3omfo842IDg9/GpnQxa16MNwXe2jaZH77vz0bjYxoS3t6MJeBcHg5vm2nHzfgbpTTsS65ByLyk82Tj4c8RkQpxsl2ZksK4bz33a4SU92qO9IqT2WYVAosc5mGzeM8PR93afvmamdTrvRhuGDL1No3fnaDKEFOyMS12t63/xE4IZR9L5kzUBM9cf2801afVTEjReJQop8jT442smNpD9eXI2DGbu6T2CnxEfTRdTJJXv/Tj6p0St8663iVH4gxA9GLQ7/83MXC5Hdj7a7iL3fIDTj6teU2FoxxE7cxXM9LCOpNALnSnBh9i6aNsRJz/NeP+luSBEFwyNXOkHqhh4g1rJrzxnOW5oA97cZHjgupAbjQeqFBV6C7kCFVv8yUWegf1VK9Y0kIrwqi45yzNwsSw3ORdr3G80hNQoecU1y6ElEuB1FGdNGlYxtSyo0PSel1xvM7LiWqSZK6lAUVOl+XJTUoV6o2rZMFCRQ0jBxUpxsWYVE3oBLiAk2FcmNJqClmWCInSjC6nSfljKeqv4utAoZJkz1eCeoeT0vmQXKLHFsqS8ypDTiq7Z3CV1wRRJZZft8FCwFEp4VIAuNZci0VhKoRVd6gxaKv299YE3LANVvEmCrJSsMpLklKtUwkXqE+wyJUmNVxeRav7fNOz7QOSMllysG3Dx6nwLQv7xziwew5fbxefF3afZO9IDq7hGeXn95P9m8uliJmvvD6PJwF23eHOSNyd5c5Kf10n+DQAA//82zaErgwgAAA==\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RRwXLrIAy85yt4Oj+HaU89gPsT/QEFy7FSGTygOPHfdzBtM9NTe4JdsbvsyP0bUtBtITPpLP3B1cMIxrMHilAJwqE/GONmUjRhwlxIPVx17F5gHyirUP9GIpuzDVT6hIXMlGn0YGeMeCYLD6OIM3lYmW5LygompKgU1cONB538QCsH6nbw33BkZZSuBBTyT81GOL6bTOKBQ4pgagsPPNege9e4Fj/iWuGRQ3pd/XNt9RAX3YTKRKRfzxtzDKVA72zr705p2PZYXJYup6S9s9/Xgysh86Kff1C6q73gio0FU3LwkK9ReabjZbdto/43wiXJNrJI+bt0Ro4/VLY1cbYt/CMAAP//mAHIYQECAAA=\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "polyfills.js", "\"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\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") + packr.PackJSONBytes("./frontend/dist/telly-fe", "styles.css", "\"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\"") +} diff --git a/frontend b/frontend new file mode 160000 index 0000000..05a69f4 --- /dev/null +++ b/frontend @@ -0,0 +1 @@ +Subproject commit 05a69f4c0f800f807f3b8c28557f401844655fb9 diff --git a/routes.go b/routes.go index 203dcef..146fb3b 100644 --- a/routes.go +++ b/routes.go @@ -10,6 +10,7 @@ import ( "time" "github.com/gin-gonic/gin" + "github.com/gobuffalo/packr" ssdp "github.com/koron/go-ssdp" "github.com/sirupsen/logrus" "github.com/spf13/viper" @@ -88,6 +89,10 @@ func serve(lineup *lineup) { } } + box := packr.NewBox("./frontend/dist/telly-fe") + + router.StaticFS("/manage", box) + log.Infof("telly is live and on the air!") log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) From 2130ad62bf17f6279a2201a7badaeecd60070fe9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 21 Aug 2018 20:56:01 -0700 Subject: [PATCH 039/182] Initial ffmpeg support --- routes.go | 77 ++++++++++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 76 insertions(+), 1 deletion(-) diff --git a/routes.go b/routes.go index 146fb3b..1ce6a7f 100644 --- a/routes.go +++ b/routes.go @@ -1,9 +1,13 @@ package main import ( + "bufio" + "bytes" "encoding/xml" "fmt" + "io" "net/http" + "os/exec" "sort" "strconv" "strings" @@ -174,9 +178,61 @@ func stream(lineup *lineup) gin.HandlerFunc { if channel, ok := lineup.channels[channelID]; ok { log.Infof("Serving channel number %d", channelID) - c.Redirect(http.StatusMovedPermanently, channel.providerChannel.Track.URI) + + if !viper.IsSet("iptv.ffmpeg") { + c.Redirect(http.StatusMovedPermanently, channel.providerChannel.Track.URI) + return + } + + log.Infoln("Transcoding stream with ffmpeg") + + run := exec.Command("ffmpeg", "-re", "-i", channel.providerChannel.Track.URI, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") + ffmpegout, err := run.StdoutPipe() + if err != nil { + log.WithError(err).Errorln("StdoutPipe Error") + return + } + + stderr, stderrErr := run.StderrPipe() + if stderrErr != nil { + log.WithError(stderrErr).Errorln("Error creating ffmpeg stderr pipe") + } + + if startErr := run.Start(); startErr != nil { + log.WithError(startErr).Errorln("Error starting ffmpeg") + return + } + + go func() { + scanner := bufio.NewScanner(stderr) + scanner.Split(split) + for scanner.Scan() { + log.Println(scanner.Text()) + } + }() + + continueStream := true + + c.Stream(func(w io.Writer) bool { + defer func() { + log.Infoln("Stopped streaming", channelID) + if killErr := run.Process.Kill(); killErr != nil { + panic(killErr) + } + continueStream = false + return + }() + if _, copyErr := io.Copy(w, ffmpegout); copyErr != nil { + log.WithError(copyErr).Errorln("Error when copying data") + continueStream = false + return false + } + return continueStream + }) + return } + c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %d", channelID)) } } @@ -242,3 +298,22 @@ func setupSSDP(baseAddress, deviceName, deviceUUID string) (*ssdp.Advertiser, er return adv, nil } + +func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error) { + if atEOF && len(data) == 0 { + return 0, nil, nil + } + if i := bytes.IndexByte(data, '\n'); i >= 0 { + // We have a full newline-terminated line. + return i + 1, data[0:i], nil + } + if i := bytes.IndexByte(data, '\r'); i >= 0 { + // We have a cr terminated line + return i + 1, data[0:i], nil + } + if atEOF { + return len(data), data, nil + } + + return 0, nil, nil +} From f1de7f04430f9f6d35ad7caf55d4d5360a1d681c Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 21 Aug 2018 21:05:45 -0700 Subject: [PATCH 040/182] Update Gopkg --- Gopkg.lock | 26 ++++++++++++++++++++++++++ Gopkg.toml | 4 ---- 2 files changed, 26 insertions(+), 4 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index 8499add..91c2ee3 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -17,6 +17,14 @@ revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9" version = "v1.4.7" +[[projects]] + digest = "1:2b59aca2665ff804f6606c8829eaee133ddd3aefbc841014660d961b0034f888" + name = "github.com/gin-contrib/cors" + packages = ["."] + pruneopts = "UT" + revision = "cf4846e6a636a76237a28d9286f163c132e841bc" + version = "v1.2" + [[projects]] branch = "master" digest = "1:36fe9527deed01d2a317617e59304eb2c4ce9f8a24115bcc5c2e37b3aee5bae4" @@ -37,6 +45,14 @@ revision = "d459835d2b077e44f7c9b453505ee29881d5d12d" version = "v1.2" +[[projects]] + digest = "1:35534a9283f212bdc542697dfca3c2700f2b2b1771e409476f08701b44c1709a" + name = "github.com/gobuffalo/packr" + packages = ["."] + pruneopts = "UT" + revision = "1aab5672bd385f2a7da18bffa961912e7642ea79" + version = "v1.13.2" + [[projects]] digest = "1:15042ad3498153684d09f393bbaec6b216c8eec6d61f63dff711de7d64ed8861" name = "github.com/golang/protobuf" @@ -127,6 +143,14 @@ revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194" version = "v1.2.0" +[[projects]] + digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747" + name = "github.com/pkg/errors" + packages = ["."] + pruneopts = "UT" + revision = "645ef00459ed84a119197bfb8d8205042c6df63d" + version = "v0.8.0" + [[projects]] digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" name = "github.com/prometheus/client_golang" @@ -321,7 +345,9 @@ analyzer-name = "dep" analyzer-version = 1 input-imports = [ + "github.com/gin-contrib/cors", "github.com/gin-gonic/gin", + "github.com/gobuffalo/packr", "github.com/koron/go-ssdp", "github.com/kr/pretty", "github.com/mitchellh/mapstructure", diff --git a/Gopkg.toml b/Gopkg.toml index 0ba7f07..546090b 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -49,10 +49,6 @@ name = "github.com/sirupsen/logrus" version = "1.0.6" -[[constraint]] - name = "github.com/tellytv/go.schedulesdirect" - version = "master" - [prune] go-tests = true unused-packages = true From d0b9a702d1aaddacc6b8ab3cbf26bf091551127c Mon Sep 17 00:00:00 2001 From: EnorMOZ <13998170+EnorMOZ@users.noreply.github.com> Date: Thu, 23 Aug 2018 14:33:37 -0400 Subject: [PATCH 041/182] Telly ffmpeg image --- Dockerfile.ffmpeg | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 Dockerfile.ffmpeg diff --git a/Dockerfile.ffmpeg b/Dockerfile.ffmpeg new file mode 100644 index 0000000..ec62afe --- /dev/null +++ b/Dockerfile.ffmpeg @@ -0,0 +1,4 @@ +FROM jrottenberg/ffmpeg:4.0-alpine +COPY --from=tellytv/telly:dev /app /app +EXPOSE 6077 +ENTRYPOINT ["/app"] From 3ae6861baf30da303c048228d450883b001ee391 Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Fri, 24 Aug 2018 13:58:10 -0500 Subject: [PATCH 042/182] Add ffmpeg flag --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 27f0233..d815010 100644 --- a/README.md +++ b/README.md @@ -22,6 +22,7 @@ Here's an example configuration file. You will need to create this file. It sho Streams = 1 Starting-Channel = 10000 XMLTV-Channels = true + FFMpeg = true # if true, streams are buffered through ffmpeg; ffmpeg must be on your $PATH [Log] Level = "info" From 1f373f358796c74ccacba69d238c2ffb3a626195 Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Fri, 24 Aug 2018 15:34:53 -0500 Subject: [PATCH 043/182] Add supported providers to comments --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index d815010..1377a04 100644 --- a/README.md +++ b/README.md @@ -38,7 +38,7 @@ Here's an example configuration file. You will need to create this file. It sho [[Source]] Name = "" - Provider = "Vaders" + Provider = "Vaders" # named providers currently supported are "Vaders", "area51", "Iris" Username = "" Password = "" Filter = "Sports|Premium Movies|United States.*|USA" From 3a56ec25170d09ee8e44728f75848312870499ff Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Fri, 24 Aug 2018 17:27:47 -0500 Subject: [PATCH 044/182] Update readme Add comments to config file example Add ffmpeg notes Expand Docker notes. --- README.md | 83 ++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 51 insertions(+), 32 deletions(-) diff --git a/README.md b/README.md index 1377a04..30acec9 100644 --- a/README.md +++ b/README.md @@ -4,12 +4,12 @@ IPTV proxy for Plex Live written in Golang # Configuration -Here's an example configuration file. You will need to create this file. It should be placed in `/etc/telly/telly.config.toml` or `$HOME/.telly/telly.config.toml` or `telly.config.toml` in the directory that telly is running from. +Here's an example configuration file. **You will need to create this file.** It should be placed in `/etc/telly/telly.config.toml` or `$HOME/.telly/telly.config.toml` or `telly.config.toml` in the directory that telly is running from. ```toml -[Discovery] - Device-Auth = "telly123" - Device-ID = 12345678 +[Discovery] # most likely you won't need to change anything here + Device-Auth = "telly123" # These settings are all related to how telly identifies + Device-ID = 12345678 # itself to Plex. Device-UUID = "" Device-Firmware-Name = "hdhomeruntc_atsc" Device-Firmware-Version = "20150826" @@ -19,38 +19,40 @@ Here's an example configuration file. You will need to create this file. It sho SSDP = true [IPTV] - Streams = 1 - Starting-Channel = 10000 - XMLTV-Channels = true - FFMpeg = true # if true, streams are buffered through ffmpeg; ffmpeg must be on your $PATH - + Streams = 1 # number of simultaneous streams that the telly virtual DVR will be able to provide + # This is often 1, but is set by your iptv provider; for example, Vaders provides 5 + Starting-Channel = 10000 # When telly assigns channel numbers it will start here + XMLTV-Channels = true # if true, any channel numbers specified in your M3U file will be used. + FFMpeg = true # if true, streams are buffered through ffmpeg; ffmpeg must be on your $PATH + # if you want to use this with Docker, be sure you use the correct docker image + [Log] - Level = "info" - Requests = true + Level = "info" # Only log messages at or above the given level. [debug, info, warn, error, fatal] + Requests = true # Log HTTP requests made to telly [Web] - Base-Address = "0.0.0.0:6077" - Listen-Address = "0.0.0.0:6077" + Base-Address = "0.0.0.0:6077" # Set this to the IP address of the machine telly runs on + Listen-Address = "0.0.0.0:6077" # this can stay as-is -[SchedulesDirect] - Username = "" - Password = "" +[SchedulesDirect] # If you have a Schedules Direct account, fill in details + Username = "" # This is under construction; Vader is the only provider + Password = "" # that works with it fully at this time [[Source]] - Name = "" - Provider = "Vaders" # named providers currently supported are "Vaders", "area51", "Iris" + Name = "" # Name is optional and is used mostly for logging purposes + Provider = "Vaders" # named providers currently supported are "Vaders", "area51", "Iris" Username = "" Password = "" Filter = "Sports|Premium Movies|United States.*|USA" - FilterKey = "tvg-name" # FilterKey normally defaults to whatever the provider file says is best, otherwise you must set this. - FilterRaw = false # FilterRaw will run your regex on the entire line instead of just specific keys. - Sort = "group-title" # Sort will alphabetically sort your channels by the M3U key provided + FilterKey = "tvg-name" # FilterKey normally defaults to whatever the provider file says is best, otherwise you must set this. + FilterRaw = false # FilterRaw will run your regex on the entire line instead of just specific keys. + Sort = "group-title" # Sort will alphabetically sort your channels by the M3U key provided [[Source]] Name = "" Provider = "IPTV-EPG" - Username = "M3U-Identifier" - Password = "XML-Identifier" + Username = "M3U-Identifier" # From http://iptv-epg.com/[M3U-Identifier].m3u + Password = "XML-Identifier" # From http://iptv-epg.com/[XML-Identifier].xml [[Source]] @@ -58,42 +60,59 @@ Here's an example configuration file. You will need to create this file. It sho M3U = "http://myprovider.com/playlist.m3u" EPG = "http://myprovider.com/epg.xml" ``` -You only need one source; the ones you are not using should be commented out or deleted. The filter-related keys can be used with any of the sources. +You only need one source; the ones you are not using should be commented out or deleted. The name and filter-related keys can be used with any of the sources. If you do not have a Schedules Direct account, that section can be removed or left blank. Set listen- and base-address to the IP address of the machine running telly. +# FFMpeg + +Telly can buffer the streams to Plex through ffmpeg. This has the potential for several benefits, but today it primarily: + +1. Allows support for stream formats that may cause problems for Plex directly. +1. Eliminates the use of redirects and makes it possible for telly to report exactly why a given stream failed. + +To take advantage of this, ffmpeg must be installed and available in your path. + # Docker +There are two different docker images available: + +## tellytv/telly:dev +The standard docker image for the dev branch + +## tellytv/telly:dev-ffmpeg +This docker image has ffmpeg preinstalled. If you want to use the ffmpeg feature, use this image. It may be safest to use this image generally, since it is not much larger than the standard image and allows you to turn the ffmpeg deatures on and off without requiring changes to your docker run command. The examples below use this image. + ## `docker run` ``` docker run -d \ --name='telly' \ --net='bridge' \ - -e TZ="Europe/Amsterdam" \ - -e 'TELLY_CONFIG_FILE'='/telly.config.toml' \ + -e TZ="America/Chicago" \ -p '6077:6077/tcp' \ - -v '/tmp/telly':'/tmp':'rw' \ - tellytv/telly --listen.base-address=localhost:6077 + -v /host/path/to/telly.config.toml:/etc/telly/telly.config.toml \ + --restart unless-stopped \ + tellytv/telly:dev-ffmpeg ``` ## docker-compose ``` telly: - image: tellytv/telly + image: tellytv/telly:dev-ffmpeg ports: - "6077:6077" environment: - TZ=Europe/Amsterdam - - TELLY_CONFIG_FILE=/telly.config.toml - command: -base=telly:6077 + volumes: + - /host/path/to/telly.config.toml:/etc/telly/telly.config.toml restart: unless-stopped ``` # Troubleshooting -Please free to open an issue if you run into any issues at all, I'll be more than happy to help. +Please free to open an issue if you run into any problems at all, we'll be more than happy to help. # Social From 8494e6ae0d4509d8f7c80ab00575277607009be5 Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Fri, 24 Aug 2018 17:53:05 -0500 Subject: [PATCH 045/182] Create ISSUE_TEMPLATE.md --- .github/ISSUE_TEMPLATE.md | 45 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 45 insertions(+) create mode 100644 .github/ISSUE_TEMPLATE.md diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md new file mode 100644 index 0000000..936e12f --- /dev/null +++ b/.github/ISSUE_TEMPLATE.md @@ -0,0 +1,45 @@ + + +**telly release with the issue:** + + + +**Last working telly release (if known):** + + +**Operating environment (Docker/Windows/Linux/QNAP, etc.):** + + +**Description of problem:** + + + +**Contents of `telly.config.toml` [if you're using a version above 1.1]:** +```toml + +``` + +**Command line used to run telly [if applicable]:** +``` + +``` + +**Docker run command used to run telly [if applicable]:** +``` + +``` + +**telly or docker log:** +``` + +``` + +**Additional information:** + From ce9a279b9e70ce8a11c11b2e04f2cdf34c71c38c Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Fri, 24 Aug 2018 17:54:29 -0500 Subject: [PATCH 046/182] Delete ISSUE_TEMPLATE.md --- .github/ISSUE_TEMPLATE.md | 45 --------------------------------------- 1 file changed, 45 deletions(-) delete mode 100644 .github/ISSUE_TEMPLATE.md diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md deleted file mode 100644 index 936e12f..0000000 --- a/.github/ISSUE_TEMPLATE.md +++ /dev/null @@ -1,45 +0,0 @@ - - -**telly release with the issue:** - - - -**Last working telly release (if known):** - - -**Operating environment (Docker/Windows/Linux/QNAP, etc.):** - - -**Description of problem:** - - - -**Contents of `telly.config.toml` [if you're using a version above 1.1]:** -```toml - -``` - -**Command line used to run telly [if applicable]:** -``` - -``` - -**Docker run command used to run telly [if applicable]:** -``` - -``` - -**telly or docker log:** -``` - -``` - -**Additional information:** - From cff0e4a89c2695b2f5604765c37acf52dd146d94 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 22 Aug 2018 21:58:26 -0700 Subject: [PATCH 047/182] Begin migration from config file driven to database and API driven --- .gitignore | 1 + Gopkg.lock | 31 +- a_main-packr.go | 18 - api/a_api-packr.go | 18 + api/guide.go | 62 ++++ api/guide_source.go | 17 + api/main.go | 84 +++++ routes.go => api/tuner.go | 241 ++++++-------- api/utils.go | 179 ++++++++++ api/video_source.go | 75 +++++ context/context.go | 75 +++++ frontend | 2 +- internal/go-gin-prometheus/middleware.go | 402 ----------------------- internal/xmltv/xmltv.go | 175 +++++----- main.go | 29 +- migrations/00001_init.sql | 77 +++++ models/guide_source.go | 129 ++++++++ models/guide_source_channel.go | 109 ++++++ models/lineup.go | 92 ++++++ models/lineup_channel.go | 100 ++++++ models/main.go | 63 ++++ lineup.go => models/old_lineup.go | 79 +++-- models/types.go | 56 ++++ models/video_source.go | 128 ++++++++ models/video_source_track.go | 107 ++++++ structs.go | 121 ------- utils.go | 16 - utils/main.go | 16 + 28 files changed, 1643 insertions(+), 859 deletions(-) delete mode 100644 a_main-packr.go create mode 100644 api/a_api-packr.go create mode 100644 api/guide.go create mode 100644 api/guide_source.go create mode 100644 api/main.go rename routes.go => api/tuner.go (63%) create mode 100644 api/utils.go create mode 100644 api/video_source.go create mode 100644 context/context.go delete mode 100644 internal/go-gin-prometheus/middleware.go create mode 100644 migrations/00001_init.sql create mode 100644 models/guide_source.go create mode 100644 models/guide_source_channel.go create mode 100644 models/lineup.go create mode 100644 models/lineup_channel.go create mode 100644 models/main.go rename lineup.go => models/old_lineup.go (91%) create mode 100644 models/types.go create mode 100644 models/video_source.go create mode 100644 models/video_source_track.go delete mode 100644 structs.go create mode 100644 utils/main.go diff --git a/.gitignore b/.gitignore index 9143f10..83fb9f9 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,4 @@ vendor/ /.tarballs *.tar.gz telly.config.* +*.db diff --git a/Gopkg.lock b/Gopkg.lock index 91c2ee3..e1a0c8c 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -80,6 +80,17 @@ pruneopts = "UT" revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168" +[[projects]] + branch = "master" + digest = "1:7654989089e5bd5b6734ec3be8b695e87d3f1f8d95620b343fd7d3995a5b60d7" + name = "github.com/jmoiron/sqlx" + packages = [ + ".", + "reflectx", + ] + pruneopts = "UT" + revision = "0dae4fefe7c0e190f7b5a78dac28a1c82cc8d849" + [[projects]] branch = "master" digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" @@ -119,6 +130,14 @@ pruneopts = "UT" revision = "57fdcb988a5c543893cc61bce354a6e24ab70022" +[[projects]] + digest = "1:3cafc6a5a1b8269605d9df4c6956d43d8011fc57f266ca6b9d04da6c09dee548" + name = "github.com/mattn/go-sqlite3" + packages = ["."] + pruneopts = "UT" + revision = "25ecb14adfc7543176f7d85291ec7dba82c6f7e4" + version = "v1.9.0" + [[projects]] digest = "1:ff5ebae34cfbf047d505ee150de27e60570e8c394b3b8fdbb720ff6ac71985fc" name = "github.com/matttproud/golang_protobuf_extensions" @@ -262,6 +281,14 @@ pruneopts = "UT" revision = "c88ee250d0221a57af388746f5cf03768c21d6e2" +[[projects]] + branch = "master" + digest = "1:6b5a4150d244cc9966fcf654c8354c96827786bb5b59cc09604cd0c566e35b02" + name = "github.com/zsais/go-gin-prometheus" + packages = ["."] + pruneopts = "UT" + revision = "f09dfa9cedec6f3e4ed39e49cceeda09cbed464f" + [[projects]] branch = "master" digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8" @@ -348,16 +375,18 @@ "github.com/gin-contrib/cors", "github.com/gin-gonic/gin", "github.com/gobuffalo/packr", + "github.com/jmoiron/sqlx", "github.com/koron/go-ssdp", "github.com/kr/pretty", + "github.com/mattn/go-sqlite3", "github.com/mitchellh/mapstructure", "github.com/prometheus/client_golang/prometheus", - "github.com/prometheus/client_golang/prometheus/promhttp", "github.com/prometheus/common/version", "github.com/sirupsen/logrus", "github.com/spf13/pflag", "github.com/spf13/viper", "github.com/tellytv/go.schedulesdirect", + "github.com/zsais/go-gin-prometheus", "golang.org/x/net/html/charset", ] solver-name = "gps-cdcl" diff --git a/a_main-packr.go b/a_main-packr.go deleted file mode 100644 index 3d00397..0000000 --- a/a_main-packr.go +++ /dev/null @@ -1,18 +0,0 @@ -// Code generated by github.com/gobuffalo/packr. DO NOT EDIT. - -package main - -import "github.com/gobuffalo/packr" - -// You can use the "packr clean" command to clean up this, -// and any other packr generated files. -func init() { - packr.PackJSONBytes("./frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"H4sIAAAAAAAA/+xU3W7bNhi951Mc5KoFVC8Ntq7YVRmLtohJpEDRzXwpS7TFTCYNkW6QPf1A2WmR7RGaK0Hf3/nO+YjT+cl8eAxf7ha/LX4nFddk6U/Pkz0MEe+697i7/fjrh7vbj5+RG2cD6nMY/m4n842Q2kxHG4L1DjZgMJPZPeMwtS6aPsN+MgZ+j25op4PJED1a94yTmYJ38LvYWmfdAS06f3omfo842IDg9/GpnQxa16MNwXe2jaZH77vz0bjYxoS3t6MJeBcHg5vm2nHzfgbpTTsS65ByLyk82Tj4c8RkQpxsl2ZksK4bz33a4SU92qO9IqT2WYVAosc5mGzeM8PR93afvmamdTrvRhuGDL1No3fnaDKEFOyMS12t63/xE4IZR9L5kzUBM9cf2801afVTEjReJQop8jT442smNpD9eXI2DGbu6T2CnxEfTRdTJJXv/Tj6p0St8663iVH4gxA9GLQ7/83MXC5Hdj7a7iL3fIDTj6teU2FoxxE7cxXM9LCOpNALnSnBh9i6aNsRJz/NeP+luSBEFwyNXOkHqhh4g1rJrzxnOW5oA97cZHjgupAbjQeqFBV6C7kCFVv8yUWegf1VK9Y0kIrwqi45yzNwsSw3ORdr3G80hNQoecU1y6ElEuB1FGdNGlYxtSyo0PSel1xvM7LiWqSZK6lAUVOl+XJTUoV6o2rZMFCRQ0jBxUpxsWYVE3oBLiAk2FcmNJqClmWCInSjC6nSfljKeqv4utAoZJkz1eCeoeT0vmQXKLHFsqS8ypDTiq7Z3CV1wRRJZZft8FCwFEp4VIAuNZci0VhKoRVd6gxaKv299YE3LANVvEmCrJSsMpLklKtUwkXqE+wyJUmNVxeRav7fNOz7QOSMllysG3Dx6nwLQv7xziwew5fbxefF3afZO9IDq7hGeXn95P9m8uliJmvvD6PJwF23eHOSNyd5c5Kf10n+DQAA//82zaErgwgAAA==\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RRwXLrIAy85yt4Oj+HaU89gPsT/QEFy7FSGTygOPHfdzBtM9NTe4JdsbvsyP0bUtBtITPpLP3B1cMIxrMHilAJwqE/GONmUjRhwlxIPVx17F5gHyirUP9GIpuzDVT6hIXMlGn0YGeMeCYLD6OIM3lYmW5LygompKgU1cONB538QCsH6nbw33BkZZSuBBTyT81GOL6bTOKBQ4pgagsPPNege9e4Fj/iWuGRQ3pd/XNt9RAX3YTKRKRfzxtzDKVA72zr705p2PZYXJYup6S9s9/Xgysh86Kff1C6q73gio0FU3LwkK9ReabjZbdto/43wiXJNrJI+bt0Ro4/VLY1cbYt/CMAAP//mAHIYQECAAA=\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "main.js", "\"H4sIAAAAAAAA/8z9e3/bNrI4Dr8VitujEEewIqeX3aWMalPHad0mTjZ2ellV60OLkMSaAlQQsuNYel7788GVAAnJTrvne35/tLFAXAeDuWFmkNwWJKe3/Vt8tcqm199XlKxQoGyzGU9Af7WuFsl4/PkE3n+eztZkygtKEgw5JOAe9/GHFWW8QiSJP74nVzHYwikjuVcT3JtfEUkwuGeYrxmJ3jK6LCrcZ7ii5Q1OQJ8vMElsS3B/k7GII4JvoxPGKEvi44wQyqNZQfJoSfN1iaMncQ/34icxGPIFo7cR709pjlH8+s2L969OLs/eXFy+fPP+7EUM+RZsSf8a31XIGUNNZjzZQmJmggh0FgZJv8hRLFYVb6FYZAsM8brCUcVZMeXxkPRZwsFQzJ0hHwxqrIShN1e/4SnvV5i/ZZRTfrfCb2abzf3l5Ur8vrxMx5NtQSqekSmms+g5Y9ldt+v3hvu2OuLbzaYBcsoSMQcSFSTigPcXWfXmlrxldIUZv0sI6HYTPCYTxMdkArZANtsO7VbR1taBe74oqv6Ukoqz9ZRThvCWyWoQ91dmJYisyxIhxEd6mVOGM44TDtKEONV4/TcUe0zAVky4aO9OUhiIZVVVzIm71nqlHBJ0CBnK2Hy9xIRX/RKTOV8MyREbkl4PmIpUgqSuJ9av+7czaoCrP83KMuGQKqhRATU6AUONyngL+tlqVd4lAkLQ9uzCMxNzVRgdm8IYITEYnUXnd8srWna7eKz+6hccs4xTNoEEDcw4fMTVTDBI7wn+wNMWrCLc7ZKvEdaLF9NFN7TIowGA9zdZucYpFsOQXm8Cc0pw2sHb7XZr51mpfZe482kzHRazpEOAmYc6ApDCAhEza5ih8WTI2Z3ctWGiZiaQZbPhBwfR1wPQ7XYShoq+WF4CQF/McQgyRYhYXy4BbKcZny4ERCm6x4I4pHi7nRUkK8u7e9E/63Y7TDbudhOCir6aFuh29WQKYOsXs4QCRT5oX/a23epVZDVg1kmNaxiNJ5CjwZAftdCN93oAIyzOyTTjSZXUiMYnwMEZ23NZU8UAwLE8FlPUOYQrdK+pZqogByvMo3WFX+AVw9OM4/z8jkwXjBK6riTR/C4jeVmQuRhiivAWzh/dwqLUdOvg8Uz0VGF+USwxXXOXXisQ4q06yAt0Py1phfO0M4A+smJwv4Vq29yyYpas+o+am94tPBSz2cIpXa5KzLF7HLZbmCNJOPtFJf/1yUZ9XGKyXl5h5kBcb6Wz6huniaBvHSQaUkk1mlt1B+foHqf3LtSWAjwCLVUXdzvIhUVrXW/exwjDuXM8r5yvdwjDpRzyFnkU0VTmCVEnmQl8lCRMDEhGRK+wF0dyG6qITqdrxnAe5WtWkHm0JtX6qpqyYiV6Sn8lURT3SH+ZrZIQU4t477AXgyju4T6n55xJBNqC/m+0IEksm4M0jsFmI6ZgDgFTx02wWdYn2RKj+L03sNz1GAYZZsKgQ7EBZObQ0oRDDCDfJrI5gJcuT7HQwQJWiqVJPBUnTP68XGUMEy4ZmVdSuUXuNPUHQWvURwu+K4ywOg/cnnyHzbj1GpIPhhx1DiVRdSZpKLM7Lci8nxWkqDULWKDAtIfe8gd/bvlDQx0zdHAIK8RGTKNZOhiSIRAC1pLeYAkiAAnq9bKjqttl42yy2cgeillSJoLJXiUU1BgLEEJzAVsxR4zwZpPM+zhyJKTb0bEo0ugE0vG8jycAwDwpgGT8ek6FodJy7KGC5hoV40yyr5tkLQdfuxujJ7KWswD39STGk6EizfM+Hk796Tgc4DiZmnmBFCtGNgXbbTFLuCZkQv65FaRs60pS/SzPa6zgkkB2BKdECOH+yeu3F79Ybqt+ijWIrxJo5mSK86aRZljdFoLCaHrFwf00q3DNdFIixW0hrA3lF03h0mKWEI0nm01dv2MoH/EAZgilnI6Du6bcrZwAKOsFO73M8vytxD1Dx8gw0XMETRwcs8n2iuHsepjjWbYueVoDVysQa8LwlM5J8RHnEccZy+ktieIe78VRlueikEbnTq/9GGiqkgTQfrMJlaLxBGjFiQDoLsJgvr/L6lR4FFzJiaEDK5HG0IB+QXL84Y1ggsODww5CpNvl/WpVFlOcEHjYxKd6JjtH0xTFJzDVkHe7vIMQHpHRwSFCiDhDC5FKrhaD1CcXYzzxSoT8oTEVJQk3++jQHwDxNgE13zx2WXWf4Xw9xWEGZI8b9w8i12cv5WALxxNFiz/sk2x3furPKBvVfyYx+3Bu0JgJ9vaPf3gl8GQXW+aQQKYAL+RjhzkbBqkPatGv7shUYu+PQvJVFNgpvRAoTgTrahZmVyVW5UV1zulqpThcU15VJCAapEU/xxUvSCbmiBZDdZTkx8NUUh5wH6wjCFlLFFLUKqGIA2c7TjabuD3LuCAR7Xbp+MNEwSRDfPxhkoBhcE1ZoBD6M8tgJoinEPJxWeEoDJtBo5VAx/OkgBzohRk68onN5eYaYaRoSiX1eRx/mLSVXUmvt9Coza4JocYZORbXRUauoDsQgG7dQaVi5eGlPKEWRxT+9S+l/iWEa7etPEp7Gyd+QS1UyKYJBo0ejeiOPD3ikX2axkmz1x1ilcOLgr3ukMyc09kY5zIMTAcr+kE4Xu4ApNvQAEyt1eOYjc52wtDtrobVwx06356T/B2e3k3Ltnzqcwze4BgONj9OovRlgpBc7tExn680euVQn6Jtcgng+V4yDKlaTwGzECHOTK81YUdcylMVyswqy4SAUYFISrrdpEBq1yFDehchRfUGQNJBaNHtJmWSVMi3kREAPEGq21V0zINO/6ogeVIBAL1ilLUrZQAAmAkMIVxgaiV+SJwtxF8KC5mqoXGIwmw3xWoTD6ue2M3pdmsCEpItajgOH6ntS6GmRdpGqtNLzu7esHPMlYjHYT06FABs41bqNpTqZuK12T5E89pr3r9OSNAjV2oFZrU1gOxYerJ37QrngpQDpMmu1e9rNVRcdJaEZgPIyC1XcgqGzaoEdQYgnYUpmhzg3qy+oR741p7twwykJk/DT92regdMx0baDpha60rawGlPGtj+SeTetcPk0bsarqnkoQAHaLAAp6fGLQZnd/cOnbRLhtyxX4V38g9Z94ITMxBBzbsYsd+fNoyjHl5leSQWFgNpo+ahVRKzylr1eOR4owQ3TwmHOHBKoDgoiVD0xF+aGncOdzPp/azZQW5vKW127LA4Zc9qSQnb5ATAi33ak9aP6FWF2Y1A5c0m/sc/6p9xrdxdJ+C+tmy++xT7+phPkGtXN4z4VGCM7fLU1R5Hh9JsonoZ4fFgkrq2lUcpmVqSA9v0WuqRbx8wLF4W1fk0KzMmJJbaOujZBgNWwbKYcc/woyiQVJeH1ohS0TWbqq2GpE9X6hoG8aZ9IYAm+rAok4qck2kOaehIqRPtWdxO6ose8UnobqZA6m52XZsN32zISB4z3WWqfizAVheILtiIqfNGFU6q5YGUSgnIKdpsHk1aOyGdaNTYhIQakYCzu3On9NEEq9sNjdPtJjtVsuapB/b+yacQVrdrGHLcmfpqRH3J0FwmdijXoxeWBAlUm5ABqCWlhDetTjPKTrLposFGajO2xWh8m3D0POEA1KePW513KIToejXu8ZAsKXH5j1ScqNiXJpdj4viCBjhDR8STExTmWaVGMm0XsG5344vdar076qpYeZT7TxO/gUvgxHipIIBKm/GH5lTfI+5Yr7slGD0XartLEA3pGPLQhtQ0lyG8hYFyIkEWEKgSJvZGTrZp/qiJsLFQbxu2wueGTG02CUarvl7iZqP/ALCD2zyfUOOJEhXLVRnN6Jrkceia9qxxbRi4qu1X0wXO16W6CHzzGPNfSOe0Bh2t3nJI+3TNsbEBmp+nJMcfEINUWWPRANI9utsOY4Uao08oL2Z3Z/iDslI740GtXddDanVc/NnrQY1fj7FveGOpDVCd/xkrh9fpsTFz7OlVCjEvUAAxXWyzHjRoAJk9V0NyxLrdDte2CelYwrWRZ0wmYMitgYk7NpftFv720IBWEPD9oATsHKOVMShBt3sQPGbc2pC22rlKSnUzAPl2C1+3idTDYp1x9hg1fqfxP/5h/o63CYA/Ph68ePx6koDh0F7xaN8PKRRIFw4JAbvY2uqsgWG8QqCBE1A1di6KaG8QQcaFcOEAov5k/krAVgHsu4eWZJZzMVGTD15p1cadmhRd3K2wJkdvGb0pcpxHyqAe5RRXEaE8mlLG8JSXd5JMYUH7o5asXdMtl1VKjvwqNPt93g8uhevUHg41vX2/ix52HHpoJrGDXgqslLTyZdPC4gmbb8G+82Kl7JE9HgYjpJuMd1JS7ENGSq/h2Y0vrEz7XYLllr4SrFCXvdBl752y33TZrh5f2x5/FDUVx71JMBjFGYkKcpOVhdn7OI2Nd+MwiCu/0HW0MviiLjFvF5jhKIsqznC2jG6zKsIfVnjKcd6PRP1pRkybKCPRG4s60LBBqNwNYURZdCqO9FWJ+7HryvZRSe3+bcSbxm3Ey4SDhKrrtm92McKGTw3C3S4Ou8YozrjPMmn5V0OBURbesF2eN5iMw5iaVo9d5vlQB8ctVhUy8DvcQfGkGsK/e1qn7UUpY6GDFiYmBnxRoWhIZrvqR88Zju7oOiopvS7IPJpRFv3PMltd0AT8z8glJEIbTUTP/5SzAlu5p//cpfpaaK0YFWhsjPPif8/ZHPGQxitEoKC3bOSKmGIS32qJwXTvdQ60UAi//VTRC/K28KXnL8StKV0TLuQruwy22dBPFLeUF5C0LCF3CY6ZSfduRC45bK/XdgxTdG0nTu7Bdh/RfvJgLeD7NuEjF+E0T8a30SWktSsqU1q5FXhdHko7jh6SmCuwMe31JgDWbiTMUexNLwCA1DsZAEC2TV/Ii0M763+pWatLaYNNHr8Y4VQt5qVoKSiy9tqTrXZwwjAL2DrkPYihD0DtMRDT6KgkB1WROnh/33Kf3NeZPbjm6lGeipa35aO6qAXIHW6Wj+rF28+t+E9t63dyWyUwm4z0fwvSu4Xsfa0sLOEfWG9LOv9UwBtw/eaDy5VFfrKln4DbryVubzZxJf01nU/hXRDnLaBBGyFByBaCy1xhyc4dFrJr2yD1N442pXEWnDmzMjpzZXS6D65ay9hbSfqve36WGCp6rc4nM4oJRlQJmJAjKjWUMIF2KfLIRYs0qTGqSQDN+aDb9Md6w7chBp/UYpPZuc0Gg15sGL6rGdTk8wdj2XXnOkDSfSwh6EwqBP23b85PL05/PLk8PXt5enZ68QuAgb1wdpXVdh9p20p+qIErma7++q8Ey99A1frdtSxRx9ROIJaymzxABIBtmrSUFS5nzAEMKAa8lly+l0YroD3Tv98nutQhCdLhdDcwQjLOlBLpRk34nxVzPguKOXX/VtL57CFJx6yHdbsJ272e4aeLRHatDNL+IquM2JsrE/fVejbDDI0n4tBNeXGDpQD1J0xVqpejBihG1nh/po6Usuar4Y1nYsOYpCu3xTPj+aiNWwFpTaLSHxLI1PS1xax/WRCC2fn6SixfdOnP0HxtXceorvI8+ah2SRU/2lrm79MADrS7sJ5dt2sLNACNNWC//vK/o4kFFSnHLK+mqK41tXO5oahqOQcHkOsVfD0Y1W4eggMsBHUAIG1BoAWnhxa/Tb5xZOpfXNZbU92fm9gizfUyQGs3kfkh+QXq+AGMd2vR2vLknF3tkBk5ts+8GX1BdMiF8kF679TcG3ZB/LALsjPsgu+csXP7uNv8zQRJlOSGQ1aTRyaDRWrXsFbYx8N+gK2YCs/bbDB07tD1FCBHWNvZMKusk4iZoLpJ73YHHYS4PTEd7HpFdXAzhMP6UJu+9AJ3OnMbhzayG7AhXGjSceK5rfLgDgLIHsA3vmfreA0reZnlevI13PjEQVMGF/lLijkq7EdD9VP9Z2UsKU4CtxL+tTp2A4wp1qASrZxVmEt1DPkDXrSNUIdaXMM45IRko1b19bsBl+A/GoEgQ7xfye0HUvWmR2RIez3AxnQS9isN+qrtnJahcxr8A2NKqXcAtxwvB8M/PXPDFId+e90WDR7273pwUcEJ4+aEubVSQHFgzIQZGgzZER+yXg+QMZu4Vw+PmvI+7+O2F3Mj+qo+OAL922JL4Nqf74dIQA71OvIoRWPA8MX4I0bzcGuUWOeABoYBeKkDmVIfPKKJ47JsayWNHdDinYwg17d+sOVknlW1nbvtKyXV0xpKrlsNDjvi+xYJqjQHSZzfAkj/LNfziTMzEyJ7OV3Y2IiacosM5JGVzb+PoCH7upK1A/JR2Dy+31nT611eBZj6nyB97kBZFy0VQEfO354zR6qRTW4ow45kV+CkbZR3A5SswplhqbpLwS3DD4WfUkLwlEvsxI9UG50oUKf5kPQvGZ4dK7PxsLaNVViqLZAiV9Gsb2tYfcPMTIcypsX8SKRFQqmc1SdieEsAYd6S9yP2I/wcXQAoZ7UWWGV0qZFaLIikHHeEBsCtL5ctqhufZ6cB4geHkH99uLtBYGMKSqQDwWX9exhqDztssyHdLhOy32bDmq5Lteduo6FxaVj/aXlbkz5oRe+X2ZRTdidF7hoKA/GrsPrRQ1L4I47kHPNzNWICGp5Vbk91tV0ur3rew9r06UrhbsCm0iwcKV6vVWC6V6lJwiTsd43v7HHtAKkH9SGWtJsoayhoOjw2TENTxeY8mCnBFQBolIxR0u5cuvQin+G6FTBQDM8NTdU73hazBS20QrZgfE46lxKjeyM6pzrriEJUi0OmeABvWSHPaNoZbKGBuduqUaOe8J5KFmKmztpFwy109sKtUZf6/dWgdmrXhVuoJ+V81SVb2Fzxugbrdgun/09paYO3m5vaS99NH7ea7BMRd1qanHn5uG/C9/aM6sdVBHS5/w224Jxd7FE7XBMM7RffOldSGGpFVGwT4soPK+yrqcwxD81wTRPvjVfHKUklWPQPlSUBzhShSnFf/wUVZimrkhI6FjuFDns/f5njampUPDJ/jXmWZzw7kzahU/KbWt4FvcYkNpVUsYDdCzzTiYU6CPHRDCfurLk365hRymM7b27mvQVmzgGhx6QRCbip+ZOL4l69Hi2i5BjFl5erjGVLzDGrLi+duIMb7DvA73PrcvJLobFKxkTabrnSC3BMJl5SKY105ggrtxadt2edcACGXkYqJoWKMZ0goSVvt9uEAzcdl+MgDP/QXET37iU5BfV9ae1ywxUvGapcXATfJglGFMh4Ql0Pw3UyVguZQA7qnEZZX94AKtWlgJmX/UpB3KxBQKSRkizHYITHOZ6k2u6Y41lBsP2OYY5NDqvxZAtE1aGxTx8hMgTa2i8OiZlTwgQoxP+cfHaFYHQG54j006/zkjUiMh1TJ4DU1bj8E4MhdVZ/XFaIQqryASkVc4GT+DnJyruP+CVlJ4Qzad6mRGxRDIYvNawk5OcYxWuiAJDXfj4qTV+3q/6Fy3CtCpezbjf05SfKrjH7tqRXWXk+pSvc7YrKLlbsqAKvwmPNZcVuV/272czxZrPE8BajZn6/AYCXmuJatDjG2hp7iQ3pvsJ95dao3eiw9TEFlxjVv5R4Xh9OvW1zzB2cEjtTJa+zlWewlueG15lg6kgYcVJiTDgrcBV35J1ZXBUfsf7b62jMJgghr6ivm3a7ySVGDFgcu3QI/QdJ6B1Y2svMf1GCR7dN1wRw73jFSfov8XsLUlG/ry/B7A3y62LK6EVWXSexV8Sz6jqGbnTUCfYTaKg0bG1/0ICPKO92i+osO5PZP9Rf3On5HGsr0W7PAsWSo2aSQ/05Hsc9LJNNnWOTQwpGMejFk9g48yBkOovjnuquT28wY0WeYyJ23vnc+KJqk0Yd8dtKA3UWq3pAXtfmw6YRP/6VWJcHlSNlxFOlbauOBpA4MLrAnuXg8nJG2W3GciF3XF6iCwz3sUABYkGmE3UPbHu9xvtzyQlMapDduDF0DESl5nwQusAjnIBUhTa8w+gGJ5oRxwHn83suWHOKt1sAT1XlNzKFTVbGAL5VJee4nMUAPte/rouVLjmT7FtpPzF8owioOuHwBUZvMPytJqqnZ9+fHF+8eRcD+HqX1APuQyLGHHPUcnFpOAC8ETI0QuLflufL2bosFQgok0VpdEaNey2TLpVxTx6GXtyp/WG4FlJ+fMxs91kfvfR2CQYyyO4ndaxT87eRxFglRGyVrEHhuhInZbTNxXfv3vx0efqyTpgqgIz7Z+9fvZKAfi1+NeW/htAXZ+SulvLaOPszTn7DQGCEXP53QXMA3sJXMgLqPUbfYfgSB5BfrduJcCyLqVYVnGR68CNG91v4TUPDMhxDyFwYyNhFLij5R0ubuHa31rvcWTG6isHWrjVVpxKuKywDZNKPeAvg7xj9qAAG/4nR01/J0/kSfotR/Ot68OyvX8bwpz0iuRRGfcT73biv1545cru0W4iJDHLsBIgMnYjOS4anlOWV2r5sNWT9CvPkRwz12fwRwxlJvxNi1apKX2GtRUgpcF3hM3ybdg63AKp2v9l2vz2ynbNCE0dKBLwTgq5lqosW8a+Fw8GQHZkkhfIiRvYxZpM6U0AorkMf0e9xEhtx6ulxmVXKG6par1aUcZzHOuS0I3QT7Wxfh2hsNh1iDo3T4XtiPOntCZf9KL+Zay0qykawCNjP2yWvsLx3EmCUPKbbJTYpk5Dwh3vgoV3SvhINk7UcXkBnN0wLNIAZWg+Lo8z0U5h+KpSNi8nQ0w5O8WZTIXSKR3SDDlPv23P17Tke0S46+Nz/+FZ9fKs+fpmukff5HR5VfYVI1zipwJYrmVwj1xpSlekspVtj85TMel3hkw9FxQsy11n7hhyNTSsBAL+O7eer7cR200nIZvMNVkff2dsnYg+eRAz/vi6YwA/sEGt5vSRoERM7RmVOLTWe2W+xCaZXodgYwjD0pq/ti4Ag9+cwvES/WOIwoKgzgMQuVRUGzoNF5cJZ4rlQTKZvDW+ycUWL7AZHYzPjTT2xjTOdjRluElEWjfW6J8bNkGCVx0uATU/SpL26l0SCC4pBDHWgmmKw7TbRB1HSuP5yXfLCpgAT7Dmh8nsmqUfWn5EOQi/NqfwXTqhJaCFpFIUZ0hhhD6OiUuNJTZrEXF4aqvUKb8Ewk2fQw0OKiINBygOn8uZUdbtVf0aa8xmaqRRgu00YDEf4NyUPj/4rYj8AIWouJ4BVfoqGrULRWShTLsPMCwWvLX5uBbkmWBpK+EU3A8+62WaTlIjKcTgs4ADUKJaUiOjIKoTem2UrNvkt7sXHBZuuy4xFOV5hkmMyvYslrEqE0CsM7nVr9B7rzJmkr7YFrhDpzwicISL3Ai7QKymlzyxFXLgUMUeDYX5kPg5zQ8lu0GycT+Aduunr3YNz9Kx7N2JyQTeK8hiz03Ch74/NBziHDM4FKO5GNP0dw8Pu3Uhw3fTHkIwkgLPdmkWVaDqS9pIKrTx7SeXaSxYAgHTlW4MWtaZYbr09qv0MdU4ULwWDALwMdq5lUgwAFKrN/AIvV9I89jbjC9QqUdaQNVFecBxAyX3UQtB7mTRb/3olrwW2CYYMeqjoCiLQT4yimBNvDqrlKjw+wxMdmy+HlwUA8v4SV1U2x+gHLNWpni2BflIIKLu2q6OwNZRxHmrGvbcVKhNy72csM8dNJy9wExIQR22T6HMupZktgJrIGpVAKrG+8tqMWf+XqwUKMq2fOFgWHyJJDa2sUUUZySOG5/KA2VJfpf+hLUy6kiOWWat/FRITwv3pImPPeTKQ+p7+cQgQ+haPsFZbk2cg1Ync0bnMClvM/ASbWmtHvKGtRwdfR3HNxUL5IRWSOIe6UG8VyMDehpJagDozZDEZUm3H68Vp3GtbGbLR9+dvzvqquJjdJRlIz7HMhrZlKL6Pe9Tbl21sYoX9DVRukL2EjOIk7pFeDOI0Fg3GcY/14kkq810zvCqzKU7+iaFOdF1vyPe45S6izqnaKaAYy2cmR7/jRIprOfEz61XzmUys5fiU4l1q68BRHj4LqK4FUReH0XJdyZANoT3hPJoxuoxkKKo2sUc6W1Ds2EFEj9bPsKEUaklWmfwFU68VRNCKN1AkZmRIDTEXAwlIdZno7m9dG+UlzYftCBS9X2lkSXM0tpr3xObwjT7Din/Cv3W5ouuaArvWK8lgQ2Z/7JrYjV1fG9d9VZwBuSfS7d4wsNasnxtVNcpEI7UTUhyrbfqxc0mgcQQqSX4wzI5M38OsluTZOAtI8rXxBSHUvO0ZFRv0t7aEXxtkdrT5oi34x/vqP0vpTl2gMnrAz1jKTlauM4UM2F3kW0XFla2OB60IY9w/Wa7LjOMcDSYoNj9iKD6dZTIc4XCCYvWnLqYEo2eikBJddL7Icnr7gi7R5xMU21+xoOP3WwCJ8h9thSrMxEGJv+of9j/Xl2fL7DfKTJH06+VJ3I/BeDDRFQoSrnA4MayWTxeBCtpz8Zmhvf0YbBNdDUDGUUzmL/DVen6sjzKksuwNK+YFyUrt7V3IQvnjFZ3PMXOuzDLuAZfxifNiiP+Nut/WobN0uOfa6uCwcXGlHdKcqydDNUu+03xmXRsqWmKk/w3J4YuM5CVuBnz7KQJnBck9UCmFsP6owSrDA8PIWPDJZrOWquSQJd7sYHzy7t2bd7G8q+92W1/fvDv99vTs+atIV1OiWriT6PjN2cXJzxexDCfxLtSdeQanOJI7rP6ftpcm9xhoJ45Wxx50wtY2VCm1pduthLg5BLKEt2yiU27tuhcLHK0YrjCZ4kiIDIuiiiS1iJYZu65qNkVZlFXRFS7IPOILHAneYz/1YwBXHN1v4Uz+fyGxMOctlnvj5COwLCoX7DTn2gYKYM7Vnd4u3GtlVhu65joCdaiKZ5kz6XTUfF/g2cXdCquv51hb+Ch5gSvO6J1fnKtC5Ut/xZMxnoQywTCxY1NcVYZTihES9e7SOeYyw0m3eyU0vn2tjfVAxqV6SzEmwiU3Oo1ySDL+4+8o5WZs5DVcZFUy5SAMg7b47c5KqcLboIKtAdNySsmqCjN+RvkLAzmTbNgB5UCFfXlw3zcVIQS9MRUTMSP7FJG71GmJM2aGqzv2ilsQ0F8bisxe+4GSAF+07ccDExsVAIJ5rgn9omMnJAykzeyLLtHid+HvnbZFuNKnNd8E7LMJQzLcuKkLsG6XuWLBAkuVpCFYbjb6wFqvk0y7BRdutVMib62TDMhUzPM6xtZFVSxFDDvxjpi457l+l7OMY1nPoNezLul2b4yznUk7peRJXm/5L9Iq1XjIowXwUDiDxcBAjLWhc4usirKS4Sy/i64wJpFtJLi+n1+ufeR3OhFDhhIsLYsAWMBLLIRUP+jG1J68lu/umc2ABbJbT0c4pTCrvYKoaGE11c1mwYcuxKkMSKX+cACqmGamwCLJQwHaAAmYmtJILFvduBWgF0eY5FW0XkXFckUZF8yh4BUuZ32ly4TPm3o2oI0xhaBtzCgowM6zr3qvwD3XbeXBuRKV9adgCrwdFJl71KOfY+njXoDt1oxnASoJtvN77zA+6b7iSfb46tsgXpkqAbnplltkGuHUM5VDEqgvq0KCVhwyw5aLWXLLnQwHc0NquG97h8bwTnYa3q1RnQXuEn9uXhxsw1b7UFu3giOgCoogrZjSyAZ0jzbnjLGlbzbyPHRUXWedFAxDoxF8m1DXrkhdu6IdFIgRDc0SOCuEQQ07CdHNpjOQGVoccztrE3Zl7GHdrj2wTLdoHcbXxQecK3vVQfv2m2tlzlgFwwNR34pB/8BYvCdVHzFWQlEtiqw47AwAMGc3tJE8MQNu20efQwqGXHp4yTo2pjxQsyl4a0bSdjPgxtiKZnw/eXP9CBSbJnWEoulkJZm+/jnj0PzJa5MKgG0rnKrV7do/mlUSgvQ30O0qEiQtxY7AE8zR0ajREHlUDg6btU/+4cMtxNMDikun4/rHdrsBjyPn+0h6KEjjZ9s9tVFsZAtPdE3DPEMwKbctaOUmldTLhs0GTGa18NbOfrcI2O+M56u2cUVFFS2LqhJMLiNRY4BIupoVXD1oNaxpQzh6Ftci9ZInFoMcE9mS70ohomTPFW/Jnp1DAO+t57LxGYDyQKVkNJ5Y92U7yhU3L93ukb1bPjC6Vap1A9vbLX/gmU1b85J7CLYvdWHtyfioNnUEgkCFD7Wu+3y1KoupdB2NTsVOZWXxEbMYwJOdmqaXsFfJ9auVaFzZuF3bU/1kSk4J9n6YTMAyDFL93cj1y+3LyBiKv5UjfFjvYmvizL968FWGeoZmOdJE5Ho/6ikPoPNW9NYKcGbNDecR71vAccL7PmaTBAwvuXx6UJscKdgaD1YZgtB+nlpmHeqrOy83pAJrECVSr5aHwqYEILWe52zNYKutH+ceRpzmsUNCLmrzRBz3rnkC6v85DoCOEUNZSfszRpfHi4wd0xwnf/9r73XGF/1ZSSlLnn353/IXy0hOlwnQlrV39TTelhmfUbZsYOVpqMaLGMC39YdstfqGUl5xlq1eFRXHRDZ9vttsF8yFT+ce3dcWL1HeTLzdv80YCVYWH1RtjyqfcftqrUNa360JL5Y4mtLlqigxM14OJc1ynMcKRG8+bRW6L6U8nd+RaSO5jZiCmI2/Hq/V8+qPNSP587KsPc3/4OCNXj5hMiXO2HE29QNSdtV52bAftqweajqnebOWOD0vuD/Eb43fr/3fNR786HBn49pJ5f7L1Uaabanc4L5bZz96UeQykWaW51HBI06jf5xpLVn6gzte/k5aTT5+zyfyMk8M+x2Hrzh8Lw3wtnoMX34akmnqaDt42ZR37Tb9yO1pgB8fM4j1A33JVatvHjCAKhOy76V4aawHxg56qQBb4NpJ0afiOEC58ZhNho3myuWmb3dMiGWQ1mrQp0LJM//bQWpzV4ebV67UCqXQ4xbsGkX6Z3SMwC+3wc2S9ztPmrAy2/Q7/5PBvUb74ZD1nY1g/QqX2i5r/4TMhyXiDdiKLuTdAOHnuk0l/T2ahZD1C7Ja80p6yos/IOvTNddF+q+9UYsBD2jo5pNT921aC9dhO7qOfszQgSXfJq85gP9skIZvG79/CgT4XuH+LZ9pgHaSDt5sOsl3MlaAZVOhVyevOPqO9/GNfIV5AIDv68F9X4B1WcrD/wNHPzlp9Nw6DbFaeXG8MsFJytApbUZpsPm/+BZ+v7v374Rckt04/UC+oye+hZ/tRsCW7blzqBXVPRhJ+peXhWYkgRxEblTNsvCfw8GNxBd7wlMDQaKNx1dDZjB5zZWFbDDiy5AH3n7no8Q8u22WNXK7Dj+Zb/V4m6t16yVp9XJ06FwbSfEnxqnzijYHqr84Twt0u0m2c7QHB3PzoG7dgAD/E0j/DOhCi5EAI38KVCTQryqD7M9AhbWAIUuAflIy+HCTg9/KLdBKEa6Z4NI8Z1ABWJnkJfCXh/RH6YOOSXZV4leUzM95Nr2+EATN2mJVLrL6Ne9FVr3FJC/I3EaWVValdD5mrY9Fdc7N47naJPReLEDGYuPb6DOedA7tBZnt/WS54neBCue7Wur8YXX5rnC70E2LumieUjIr5mumdPLnRPndaQ/xSjbu/1bFYCj/Uhc84s+3Qh+sbxUvicxZM0cm6F2+oqKRR+Z4RG4YH5Q/bvlM/Hu+wlP7Zpiq6/zdn1F2nTTrA6C6uMgquYvXBZk/ti8BhZ2NgcR7+bn00OSTZhpuCgDU8hOwzb229yRb4jTO1C7EcKX8AgtcpfdFpTdH9CazNVBySm7oNRbLcNlZ2DeaCJYCcb+wbRLrfWsuYhhRj2iYnoO9wmpPv0ldKdDrd1kVnKxgdQv1TXQAINGJXOOlCfOMEaL96SIjczxS92Xts0n7tjrkYlCQxsus3YE0IQcPMO3b+gCoGVvHmcCsrdjt+NeoBfA+W5M3a14VOdb7FmQd+gxL3p9QQXU7h1vX5FRUp8TZ+DavljEFXoiskN9jD13Ulak6vDu7U3c0jfGSwJ3kiYkP4jS6krdShmyIFjC6WnOhISpzQscd+4zuHf6TR9dpuHfPoNO8LGZr0nIo8Byi1Wlka/O11VzgRkBId8xtqg9YIGqjlU+EqKyilc8kqZEFaRT3GMQQE/gzhz9zL9yBmsHUU+v1caL9qeCEpfrWvLVka/LtOmO5e/W+d5269q7l+ji8M7GRovcKbi37089cKBtSuyDINUhwk2ZvgBC2PETmMgodcJvkSD7Hqx5oNY16PYhbvFQdKxX9acCnMl3pVgcHcMdYuvvHnGJsWbQ7Xj0iduWBrWP4J3L5jTWYuvJNwrrhoVyekSKcgRyjKGv0d3AAJYQl6CmBGdnvSfi/KfDsFXaCgk5IyNlhig+6+jUtdMGTsbf6w7gfatUgEI26MrHcrn0I3HVcKtGkfvpd7YFJ2aMPcyVFDH8LLvMi/4my6/oVeSFeX2XTa5WsVhbdCjFOL1DSpEqmKBLn2NNjeENUCnCcpjQV73BZC4y54/rEBYCL/DtfDJHIb5ctExr5oBG8FXrd7j3g2Bn9/MGxf+E72FwC4Afc6Le5Zbh/ydbk2OzQ6ewdznLlZLdtPeRZkCnDWYX1gXyHf1/jiu9KYdZGnB46bOLIIIBf/qA5ftSg9mFxt6cDO6BbejRos3f9PcqEtin1EFzxKrrCJb2NPmJGHduyimAKQe3BxViCtQtc7v44yeK9LrvdjodLIRLZcCMOzHb33aFHWhMAfCSaUZYMlYdLfbKNIbm+hHe+regqAUN5C2EUd97n6q/TXAitOSX4+CqpTxHYuifqcAtqHx9tCZ5jrhctCEBlkgc7xKbxuz8rSo5Z4JK7g/vrVZ5xfHy12Tg/Eg42m8SbN3bn3Tm0froOQrddSd157tr4JqEbBUtrNaGSAWHttdyrEL7UJNqFRfUWs4LmxTTF/TzjWb8ugTkusztTLn9AafssKHlF1X15qi3EThH8sGCmEc/YHPPtFqTjScMpM88NyrV9aa1PFKTo4FDmuv160O0mFO2w7rgbyx61q5GzVx2E6BZAnDC7U5C1UUg+Pg6aXEsHLiscTTG0vaYUGlRJSZNW3i4waZ71+sVvYs5wc4dblOmJmFvEdZXoIyVYqDgmlj4S40SrzPqmqBlFZvZCXamnkoB+dFpF8UdlXnmaFxV/KqZwYAbo/1bF+ip29ESfKWcn9RLgHhq4C/0/mVs0nrkuSG58IqsdOoZEQSHprB+QOC+z2iGkjhMoiVjqBf1Jpv/SaRGDV1zzouKYOV4lDQe09iDaLZo3wLMm+zsLdqW9VpvX805fZfncXaArUrW7My7wzX27wELuKcqC3+3Wv7ye1A2eynvT6u55WdY9FjhECZWz0YzRZRLoXfo06ZRMra7fUcpP1Lutn97zNb5r9ysQzgHBKblgeEeioOb1zAAIXAp2YB+VUa9wc8re2iyK7XlbhC5l8trkU66rHVTec+f/8CodFV7v6zYBAE7lS/UrgmTGh9qvpizp7et1yYtViVVyS0cjXzhbspIdTNX7tHnwBBGV+U8RStEX4o4Wf7MrtcN4YnI7WO+ZNIp7XL+HtnAzc7v3Xo1tNN0U6I6oNGWdYrMprH+iRPcZEWKAzHMEcCLzeU8znnBg/rJZjWid0Kgz2AJHosnQJ7QbdtzNLGYJFbyEkjq8Qf0MzbLt5ijfs51mJLrCESXlXSTYy0oDrR9ph1IZ9bVi+Kag60pW4TRSl6RRppL0E9yPwZASpEKA5wTYVG/i9zuu0uqprPb7Yn2k6pH8aO6lLRxYlWZQ2qnZto5VbXsV2L0KuP2eUbu2CH8oKl51Yl3ZhxdWsw0EFdcd3BZ8EWVRXsxmWGijjSuNhQyZw0TDKe9Hb0uhxpiIkqjg0axgFe+7mctkbIvF8DvnuLS2eURJai+553tUe2N40+FhRqNfyjt7RyfXPRtfsvYX6eYYIjVXxg9N+QG0XT5sNAy0Ul9MKF3FCKGEID7ifSX+aC9VlWotI2liRJVYZvxTX1MieAy+jX7hyX3oai1dqCcLCzS2x+gXXp8jup0MXXNn861QjoL4V0DlfZIyiy0KI3FfAfNC3phnS7wF8tpPd8EBFEfcw7DSHAiBfVkQVeVf6iKASbHNop4aLUq+YfS2wkx7X0QFmZZrIbi5zwtbr/CABfGWCIFYIwIk6pXHx5geqb1A2PeKaubdT2BlUYAeb6HqTkeR2SRpgemEA9B0ek0AzFzX2pbnqPXJ0Ut7Qa2jZEIAJNs6pe4lTwowKppupsR4cj3uPsW/iJFwJFuQFjpjy3+iN8kntkkmH2z0WXjj9O0MQhvu4G8MeW73Eu4vOIAULUlyL1QiJxm6xOhj7bqZjOkEBNwoE9x053VjoMLUQr5O2VxaewMDfmTYn/qVynmF+5d2oNpF0D5WB3Z838OaeD1z6ahg8zZ1xAyUn0CfzJ3JBhmuOb3Kx7FuOaWk4mwt1gF6T+Tb8na8Fc7t7ZJNLZbjaZkxHMW1Q6RtENfulaIyi7Io9qYWR0vMF9RlS7OCYMncZTA4rnD/CRjuWlrCdXyOIR/1S5DuBtZx1W2dpslv6h52JKh2nkCIzZbH8H6OeSAbps/1thCT9VI9pJsKsdPwav0EAYAPRDdb8+KeKFIZUW9o9O5IUiFz+KDTT2Ptj4HO6/jnHQz7Qbmqzc4HjwK2bfAAtG29R4Dbu6lb7ku8ysGI9xnO11OcLAnEIC0EWZI6lKAAVztlH2hzfdn0RrV9/6N7vWFyWXDYkJaMKy3+MMUyx4tmyIjZlr4L6jvlmcoQtV0V/JxnfF2hQhddNf32HVnrpsC3zk+2JqQg84ti6lyoYDKjbIrP6Bm+PZauBfWV2GXlX8d4jqV1xzV5qMcKdbuwIRUSYO2rzj0XE5lu05Cwsj4vptf6ikH7Zak3rH3hwazEdFPfUHZMUcjyHf5sLxahM6t9NzDSMdBOQr784rrbAbgOTFoypOGjRuB2XYE7nj90u2Mnu9nsg0/wa1F/rRet7ockIDoD9VD61jie1pMPXI+Fpt+cux2l23VHPPyk/ZEWeDGppjoI7hvPhUDSfD4EDP0r5MYVh8lbBzkaDHk7oQ7v9YBMbVyn0+ETDZxdD85C/egmRXhsfO8PDq0ucpZQMEoYwurGBJoqXx8GcsR7PUizh24GQNqqTL0KUKcZY93uoQzLNOFTeDyYuBmnRqIg/TkhIPkpwZABsE0quFYPiweYjHy0KOFohWHzVJAhQcH3zYPcZKsFU/+xCAxLDFrPaeHgc1pbYMN5uWMvCMrNexTVOpTOoeNS+QgEFev3+U23UVYJOYrhSEhpFS/KUl0vLhgldF1FhaPURJrQ9yMrYrkiXEGkDeZ/PBnsf7QMpwU2lZdHyRT9GAwJ8sJcX/MRTvfzrD1hFSFmop8D8UtNxmbijv27TgfnM1cprv+TCz2dmD02Ob7FwdtsSB0yQcGw2KHM9i/XpKRZbqedFIZQZahhr6sIdN8vibJut1FjTUDIwp8U/VLff/WJTGqmzc0wMwyyOQcomKeJZHED62LjNlbYfTc7nOMbXNKV6FhsJe5Hx1lZRsrK8ZbR/DXNcQIiTnWZts3RfK1FKdEoBrBopOYs3Gs4z9/DiraOrBGwfNWgeIdnsj8xfZ3XkOHpmlXFDS7v4jo24VLUUuEPoM7548s0A1fueUgC5njKtWTiyLMBucVA/RG9Thd4en1GnW7drLBW8HmcX2VLTmyaQBq5i5ry3fdcKPyNi1TOs+nixwLfhpTfobtQeSA5gFw3uqDPV6t3eGae+PKVnL3d3pLE6VkGr+gmLxld6m6b6rp3AtoqX72SBPcXtOLiT72LSiZsCqf2AdoA5XjL4Xhi7eW7JOuAVsWb0Q3+IhrEpL2MGnLeMgzE6tnDpjrsJG1oX8qpLfxUXfBRCpzoWt6pPqDAqSkoceAxKnN9wNEPvEkj/qK2NG4qe7eeZQrXz7SDIfn64LDbxd6z7KLaJfHjx47Drndj3D+VOYEywmX2SftLZZt8kVWL46xSSSjND5tr8kNjkJPARaxH+RHewvNGo4sHbp7zgvG7muoxXK1LRwebarXLdUW0r2AHZJhlwyLmuyipzqWnSBMTldvEw221e0W7OQm6MzYbk7zVVGny4YtUv7nW+du35vpsBGxKdmR9epqDV3S5+5VU21rUajXlVJojdrou2MbqAHuNx8c4AaHX9L2mqlaTqO55pcgfuH5SqQnwCgeomMU9B0mdnTDQr6lm7bjj22cIGOGEgNRJm6NpMgNbQaK3loBr7D/0ENtfhX4xXlXIKu5/HjsND0ziVnmN1qg3aHgjEcqL2d0bYuwaTeqrD55ycA5wywrzF3LyzYbmQDeZa5jIm2Gct9e9cl9HVXf/1w0S844gk+nlbcYXbxmeFR/S2D4NJArP1zNZ2CdzXRpv4ekeQ1md1FWZ9l3L2KyYI77ZvCPhBBLZHkpQJ3molYE3XDm3iZa1gpHasuck1xcMrTPof94RUw4ZqhJsEvj+JQbwGYAUsfFgAgvExrXCXadVlLGMcY5n2brkMYAkiaeM5DFI6O6rDDwuJtvdn98K2iYfqthdh9cgCt+jNKUTB2iB5bfXzRAX66aIjw/F8uOzuW4et6BApQOehYKo7YHCRYh+CwN7rLergsLGfYCkvYdBycwFkSdNvHXd6jq71XLBi6InMs38E6FsPZEJzZ7UV6UqadDzxmE7a/x+0/j9Yq/xub7qqNNDG5OyEiXOaC6t0N2uF2z6GxnJYNPjRVGqx6r1ATGZbuXzC/LEOCZkcz7/c/cn7sT7j79MecQErJR8qlf9KTOxjf9DU9F5uz9lAvLf/8jwDEsHkimuPmUGdav/yCSMl4N02fqkifgtH3fzA38je9Jt1HFt3svc8oOf5EA+GKtDVdH9FlKhYrLias3N72mZVZX5UfG70n4QJ0ucPil804ZkzyHdkzHBHExvDdhE6NY9W+0V2wfl2k9tM7ykN7jdn+Pr7vRolCUMhgeHHXWVj9tUwWmhdSkOD0Fj5IJUmHE5MsPk+cxXCAI+Ow9NRjCQhDSrAT0F88YqXCdj2juE6nVjGHYHM2uSOW5NzhcLKA+m0h8ssLBv8Iyy3e4QOxei3hY1js+KAIM04XZGPDQjaSBxdnnXPhA4kA+TeBP+fY3Zbidb+fV5WSYYjAcT417bav+8LAMIVL+848r56pBxd34hM0mDJ3W7iSjudpm1NJm+pNee9W2FPDw/dd4+cZLNOTw46+YcWz2YvltzDhNK7jELfVz2k0h3hrsDFNx5cSnaPEA7XZhyVsznWEWymUvpgA9tuds7gIB7onxsEe52Sd/EDMjMejLDxQsC4GtSZ48ym/Oju4zXxHf8trW+k7VeE+X77gg83qNKr7yT+ZGodx4+Euf1AtLtMi/HTuOpc6M4SzFX/z0cmpzqTN0VApghqv8cFrOkkNc43a7yJQMmqr3+tNn4nw7VS25JoTzRYaYzrNrv8hUvDl8RkMqXEDs48P6ll7uyLt1s2GbT4YEGPNiAg81GvzAt5db3DzmA3io3IuS803Hr3X35zyjhRBld1mRXLdwvqp9Up8pFQ4+QysAN+y3U1DuQWKu5Lx8jSRsnZOnHaXRUHQ6qyrhjE1DKPgrqrUX10qmy4xg7vTT1jo9emtxviHyrO2mmS91sOn6y2dfZCnS7AkdlVu36GHzTzJDUkacy9A4rDiT519HWv+82P4aAoJ9srUKs5yNpqd+tVGEeynxbx+DDfzb9+e3NLvz2IUw19k5zq1aQa5y/M296WBHnck12fjJocsq/w1nufikCJRdZUbolWZ7LZL5Vs6r90GwhxIBWbVnYrClFhqxsVTblzfpFjgkv+J22W7Um739utpZRXd/cvSQIbzb/DJ4DzRVOOV62GbPMF2hMawp0Q42bfMgR718KegoMsWj1+maFWTukqX61xu3YvvnjgggyNNBPJAz5ZkMsUe+QzUaKYvrwnwoJ7uh7kqgUKSOeEpih70lSyN+wQoVXVZJ5IekBdnAACSJqKe+kRJfbHPV2jdpnorAUSPYCWK+n3EDpZpNQ61K7RtkBgyWqDpgYaN1BZb3sKRoMp0fr4dQkXVyh6RHVaD+i4+kkFf9DAzhDq950WB6hWbc7O1p3u4n8sOodgi0dN+YyQeXBervNOghVQsTR2XCC+/LWno8Hd90/SoHdN33txoLneY7zRwzlnbvASLKf3cO8Fjv3iGHsYQ0MIfvYPYRGj0cM4iJxYBzd0e6RTr2D/dDJbBOJwJh+l4Gh82I280ayLxLKrCACu2FHsoVAehzxT8TZnXwkisqwmOiJzeP6pB+9IeWdeopPvbVZcCXpVtI9JitLeovzRpS9vJtPMJDqWOB5rIB7cSv5rehih2I9tHcGmOsnerS/qE+ZMqSEvyZ39xmWzaZqDnqFBsPqyKkyrHo9YLL1WNqcVFDIsNXEPHqCim73BCdFX1c5zQVFSzIn4d4NZsXs7h1Wmq50T5ETrwCAsmnB8dKaS+TR8rdf1AcgtR0ui2opvR5MP2LRAwALVCjsUQ8GEkGVPMYeAosBQOBdR57gMdHPzEdhEV6/UNJJqBXdgRTEh4AnVAvdQtR2N5UKLK9BSiB+HDTDoMSQQuKBUohyPAxHrOHoAVH10AQiJL2ecVvRWEP8tBKcrck0k2/SGF+IslRPhdq085W8iXqcm7yqu1NZNVSiTX+VMme/WaLZKHfpXONTgCp9mhv+ZePmsvbC18syiSvMm2j2zTnKEhzkX0FRBg+xSgMlRBmfqZlyr8sgn3I60XzKZ88I+/KHpN8BcXOnpIl3sS8xMn9gOMjN5CSHGzbF1sdKrJ8urO6XU7fNeB99gnZlOhs6eIsQwiOb+0xK8WlCxToFJNzZy6ddDDlIsH5xCwX0C9dN0fsgTRzS0DVKTmTcjqAKfA+BVTYlC1dpXpUXgky/9BiYS0OlcWfT+KTno8JU/8CUmKZ3/rQcDFcfBIf/Sd39yyqw8Y5Mm3ruzFH3H1jo0KdadIRRaDUUGhxgIPXPQUemd/TLbCiHjJgX56NSzs6txRri3NJm6qPoJMCRdMPp+Z0+NYm7TomZGPGtRzobMDDejE3QmKcNw1RcHAibNdQrdciUTnrdpvVea1vi0JBQS3UK61SlvG4Tqu7SEdvILfSE5eCAbbpSj97+FhKEVbfNfEkuQrXSIfyRvbKEaGhyyUsU1WuD1GCM0UB9QsdGAWJMU+YDiBrPfjoKEGqWUm9Mi/c+JXDyu3gHgrTPg6Vr+3M+Wkz/s+MZsvRQisnd3TeYKgoemlGILxvf+Z0HCbemuw+FFBKYOYxcsSTV+pp1TNAHiBmyhjhsoIW2YWGBELIGhsGuxSp0b3WNNrOzR6hhYMO30Q8Wmj56r+RT1LBBWUkLJuoY7Mkns5dStj11C+Ird97RDB7MfceSW+mBWAruH8QGPImFJzHwJP6e8JTYXQvgs8b3sLW0KdOJ4XHapMk+JtviUVPGMxgcJOa45avsb8WuPP67OLpFoZaV1kOiJpXcgUZS/m0zAx+FXWI3CjCTgMYilu3TRMkM0qRR2u4sZLZ9iH/hIEXbaenxEEHIdnV06g5pGu1hi6PdIrpBjMcyTEXptgmAPwXT9si5mrQ9Ruk2k29vrCz2Ed3RKTxtrGHib9Zrfn+xXjWrNIqaW+/U3FFcS01O4etQzYCYsYX/eigz2aJh4edWVQrneGpRP4sEoidzDha1KiY7xOY4WXhgH2TAkBlusUB8wm69ukKrN3eodr6ukE+GVIiJM3UjU5Ohtc6/WK9AMUsSs8zNhh8h4qEUkMYe4hh76jduydDPY9VywgkmlzDLrVnCi/VqB1dYeDxBQqPJFrjHFCQYYWvb9PH64QFkWWYrczcfwo7VmgdXVMNGw3uZrcxTsWSzSdSF/7+0n6L4aB5fBVCmyGtdDO7YU7935y2mEbEPewesuns2w07ds5rV86/5uWb34pPOl8cl+X2U0UyGtu80mtmsrBI0xUf8aWYtqbW1PMNFX3UmPu+q+fuG1NgQC4bWTI+YQXWmozAHrgvFEbGRvglFZMwmALIe71F5dfzZf+7quHnjvdl88/BlsneX/AvRR+CXh+glc+SK19nKWFyyVevydrXCROsPgavi1+0W0/Cd6zR81/rpt8aPvgv+FL/e/5TB11n8HpPvp2H+4++a9f590mXzH7jUfL1zmIdvNRVbf8xd4HTvtZzu5//8+vT/wd1m6IJR/b/tJaNpxh+/alxmK3XRqFxlGteM6joLW9e2/+Nbxwba25DsHUTLhre5l3HMZBYm/Wt8J7kBF13eXeHnQpUzEc5EuTP7fdcuEO5r+rx/Ocf8DTuWtFopaS8p+wHfJQxiMCTqIaHa2/YNey57TYh8HxJIa5k6b91uov/yDIIhUug8U0kMgrEhQ765C7Ba6VVwq+2VDjGvh1AqppYGmAASgA0Lmv4JWcPTjHlOZtD/qXaGuToJc9a49SOiApbKaVPh0jTBm/8fsusqfcxcGAasU/62odbdLq7jdOXy6hg/Y0biZt2ueUpttqwhxK4HN8reS7hIKfTMZrJh83HUPiBmPDujVg2QNkYNDKqk8QasdhyCNrh8VJMP1wNPGLbftERsJtQ+pNxYivWpgdSeUCPkdbuJWTUFUIZv6aUzIak7OjFxkVNlEywk7fuZOHK5P0OVsboAsAh6WCr70HODf0nRyjnxife3zpVoUyjztg02r3YbXPxTr3MD7NnpwrLnpu+pB5QH74f3XA8H+2tLoJ8gfH6q3Nm6hW2iYwPRT3DCoT9hsNkk+5fUaOCjkUH7to3Xx7Ld1g4PAkELfggq1pq6x6wfbBecZhtajUk6+zl6zA7b6e3kEDiglLQm146XF7vYlLhGVhRMOEi1riFTo+NAOgriJtEYk4lMH6uVtp8DmROESIJ9W5/DPF3TYLN4pwkwZPJ7lLluh2nP5bpbiNkDfsr169qOT31Tq7UPPkgqUF/89J3HtVXCAClA14HzAV98/IF7PNrah22SYwzXlUmomrpbJSMXdsbGqo6jU+2R90KmtK5khmu65lEWqbimyAaN1kGzNsexfMQtx6sqHY8xFGM8V/+c4smk6YXazB5hXkr14aryR4TiB6z1QSVideBrTX1744BN2u5I9yM0CaUmCEUC9+InMqfW3QqL30nCEQYyUmazsfEXMnhYrIvMTyVcJOjwDM3qpNH5KUljRim3wfkhlVxu8Vg+UE4mUmqWp4j/ZxHw/9Oo9wO+k8f+/wj1/gTicYNy/M+iXGzIJ2FIYsNnZAKZeoIOsxpBoH6WjrOEMAALhm6IxH8YTynDMayTnp86Sc/jNbkm9JbEW2i/z4mG24944hSvTbFb+JzbwgmAGbNPPryi06zEp7n70EPFnDzcrI5yWTvl1CkvmWs+3GxiTA7en8dSUJ2yxvsVqz0Hw0iYOonBCzq1bpMEM/F7vTQhmk6lfrFcqdBfleFNodZ3F69fmRZJXGWk4MVHWeFA9hYDp+tvaH5nw4dbA/avaH6nDf3BNh4m+k3VZHS9JF7wZWlSCPsVlR5Tx6M+dm6NAcRUY5lEzO0vOOltsLgvX/kU0ENPjqqb+ddH84jKrFooVhKAPNRnNDfG/gTEXx89nX999FRUfwI74X5lHOm5Tgmo/dz2V0ri6mYeg1F4/u2Jrr4+klHiXx8Vy3lUsSmKj542Sj5ElMjn3FFWYsaTQ/D0afz1EwXvOeanu0G+c576uuIRi4mK5TwG3a57gWCfb+10buWLL/0Xb16/zViFWZ3MzglTVKat0FwvbcN0Z5VTF3nAznpoZwc/f/cudKWwo6ofZY/iI4GfXx8pxPn66Kn+QxLRo6fyYyyzDWKEyZTm+P27U0GuG4BQt4Dq0ElN+PWr7zhf6WeqhrzPcLWipJKvOqA41+uNIe/TFSZJ/O3JRQzjPONZyvEH/lScy+F0IYDH0ZrPDv4G4x6G8t30fiWNYtKJUVsDbP+SNNQPNrhB5cREIBZlDiBpXbrt3r0/DDQFEOn42UQlIM5thV8yutSZpjCM7dJj4C2kER3vLYSH9+Lh5XmYt4uN76VtHC9XZcaxlSNU9g/C44JEfJS4JEFeTz5IODR7cXiJQZXXNMf6XFecFavjdcXp8qx6zjmrdhDUMNFuJqNq9bYjvg47+TCEeG0zZw0HR2RIDg7sU3zSaSMhSsodxh+WJalSUh3GHZkneCD+sWkSYlIdpjHYbAz5fm5GEeKjGZ4i7Oz6kA4B7ROaq/OEkKT+J69OXp+cXVyevXlxshtUFECqY7fPi6uyIHMtKc0YevrvZJQmo3TB+aoabZZZUXK6mfHVhuNyMytKDNLN+N/d9OnoL5P/TkbpWPyx+QyAp/MCLkQH8ggno7RYZnP869NklF4tV5t5Mdv8tsLzzW+r+WZF5htezGabW3y1AhshEFFZcylqLFdfbOh8Lj4uwSZb54X5+PmGzjP5ja7WFQDDq6zCX30Bx9nBx8HB33u/Pp300H9/9rSoRafcEYUSjMxJA6CvYktmTAJe/VgwMMJpohLNmhSztxkjSfzT83dnp2ffppGWW4TAuSZVNsPR+3evIhlGE8nzHyUVxpEAYPr06bw/pU/J/GmFp2tW8Lu/fKgqEAMYq7Zp3HOjlm+Yo75Bhu63kojUKJDVGalgDIB8nVzH4HdUmP2wLgJsrIPrJ6gzcNKwonvJb1O8rdOnsrv7otvtmDD+hCDaV1ADJplBQr33t82LULwve9saHuTIoXfMTf8NhU46nkCGBkPWTgHOej1AxsxNAc4m+uK9AYgCZQlRUahm9SqN9LAuUnBcI/3Snb0EKaOCRGuw7i+y6s0tsfe+JZABoaWAFdhqaHFB7TW0uA+tqtvVg8rnX4oaWlxBq/BfK9fQwg1oKW+BOYNLhm5YEmcMZ/CKwSkt4YLBYjmHt1csBvBKfZ/Scs7oegXzHOYclgVcQS6lYZ5DPqOUQ5nvD2c55KLdrWrHVlBK2JcM3bHklsErBuCx/LFk8I4lVwzK8fOc4aqCGePFtMQwq4ocw6uSTq9/X1OO4TSTCXnhFBOOGcxxCXPMs6KsYF5kJZ3DvGAwL25gXkJ5e43FP6aZmCFmcHEIF8/g4nO4+AIuvoSLr6CYsfigVieWTiq4zAoCl9kKLjFZQ5LdQFrCFcOwUkFcsFovlxm7g9JcANelOBRqfXIxMLu6YjCbMkrullCSEngFr/ICXuUUXhVzCepCLIvmWC1mRiBewhklHBYS/mIi11c5LLMrXKrZZOwaroopF4v7HbL11R2UAIYVrLLlClbLrCyhfjO2WmUECjp8jcU/lMxhtb6C1XolHz+F0gsHcg7X8CZjUFJDsY5LBuAHtXtX2fRaAIbkarYLhmdQ8BjpplBSMs9xNYUrWgngVmwKP5QFuU5FvRjAE9VLxaYVFkhwLvf9A4MnGk4KSlNcVdf4DmZlMScwKznM1pyuyuwOZh+KCl7Np7SkDF5RJrZqistyleV5Qeby72qVTeXfZVZVUHrfQNVgSstK/k9AYkqXq2zKoZAUmPpAWV7BPONYwkPzfoVH9FZqOnCWTbHGkQoucDFfcLgo8hwTCYwyI3O4EDPAsKjEHgnoVFO6wvKvFaMreF0Qs4uyvvjfOpsLAFKBYnmRweWa4xwSKiFM6C3LVlAIqALr5EQYLqEMhqElhozeVvJ/YmFMvvulxqymjJaCtcJqkYnfxUf1v0qjA5vKKVQ8E1hTY3Gh4svkO8CQF7yU+EEqIWVBudvrCov13ahdUslTbtTKb4ucLwTqXOzS6bWtSzMxnJ/TJeaLgsxtGtGr9czJfefJSbqRSXG1U0pyxBQ+BIJV7JVURlpQyZh5czQRelCrzcXJz24DqRvortWlSbpzbQPoicwcuT/r6Fkx3fv9k9ViFSZ5PdehlwYLT6+PS3p1hRmu60DuylvKxio4MRleMZxdb/lDrWsdH3i3uFfrWf83WpAkjltibQ3QoPefWOZZtsR9Tl/RW8yOswqrZD7HrMkduYnOFuPJTFDxkbHX2CIOLJcV0osnLlM0GNIjZpg9NdkaCiEIC2GZApgJ5p0tMaxQ1p7UeWtSlWXyWs4ZfmDjatLtJmuUs2QNBOVTBQSt4RolxAiABABHkNrx+rcUHvucFcsEgC3QcIZRDJorj6MYZvAJip/AUzEwfBI/0U4xu3Fy2+jj6/jhJt4O10j4Kfsb2txut7MMFifNTX8a2PUmML6Om/eO8qy2b7Fsk1PWvqsMnoWAj4CKQBRMhWGjp76lVaGNzV15hF+8OX4vz7B6RebN2eXxm7OL56dnJy8uv/kFmJP+QLWWSfplVpQ4jzg1aoEQ/JdldIWn2bpSr0lgNXP5vINZTSpUhT5dc6X1Ok+W6iTFDD0d/7p+8bfB4ODX9YtvXr6ciJ/H6ufLly8nT+fwHUNPk/G/f/3Lwf8v2nQm4Om8VntOPQtwn+FVmU1x8rT7dA7jbrZcDWNgS68ZbCN/3P1L3EsOB8+++O9EbeAxzfFzngzAwZdfPvv7V6Dnlx+Cgy+/+vzZAPS++vLLz78CvXgYb+tB3u0cpNF7o93TIznlkrszfvq1LJyLwlrdeOss2jVEYMe850JlP52PL05ev331/OIklq/6mNO0TTAY4b7uvn4z9rky4b/D85MPqyT+dzI+gP1f4yf/ddn5S5QdfHx+8K/Bwd8nvY1SsJcZZ8WHjeXtm2qalXjDKJc/rvHtZoVZtRJy7g0GySj9efPL5vMcjEQHbH61WVQlyNQvvMIZL8j8AIySUVoWBGdswzIhj4ODufgDEy5qTrNyuhFUGYBff03GB4ODv/f/C0Z/UfOb9H79FYDPYhjPYwDPhDK/ZuWvSTL+N5j0wK/gs6fwTTDLPR7j/tmbsxM0mKBY/KFeCJAWncMJisUfquj84pdXJ/LFAPmXLjx+d/r2An0uSuWfqvj9u1foiwmK37/Tjd+dnL95/+745FJ8+XKCYrfAvjzwwhN+nCeuf2NNz+9KQBtSdPjXvz/rMpsHVcYgJPozOjj8698/77INgbhfkEIH2xwcws4ApKIuqVHwNfODKBPZs+4JqMdCnV6O5BvbbrekJ/ute/yRNWKXBCJWYz5xMgM+XOXVw1XeP1zl5c4qAqAfGbqvMD9WfgfiROn3h6GyGr6jVL7t4ZeeLK9wnuO8/cW+GdL+ZJ7ofIdn5gO9wYwVOX6rE+g2y8O9CSXlja5R2VLBeZ6T/P1K6CRefe91G/eLTlHvFunnn17glT/5F06+X/NFv2tzI0iKLlrL0V8UTJGAyi9/h0mOWb1MmTj/rRQS/7nGrLD1Hfz/hjWzCMQnH1ZC3S+oTuWv3PZO+XdZ9Q3G5FisF+eS26VRXVm+x6mcZPIoE02igstHVqeqRT8yLibKNJaaDOH9SOOHU05Eeez64dEeiqNTHlUYL6uoLK4VK70p8G3rKXA7fmVut1U+JDEXpahEi+wG62dDBZjqSX6XVWLiXncFiTK9tki9kSQXTOl1NIoBDAXm1BJB7f33O5Neh5BsE+pl6PxdHyI8ZnyCOMTjQvzbL+lcPQItdMCEOy3+yRq5AbX0IZDthXkkVO/Rcy60XS5EEiGAZPVDqRJ6UvBQyQ2/9ckk/Im1M5P+qzZIop9YI+6IbzYJR9pP/DLu/cRk+A4U/+pwJAC5HOsHhuLPPlsTFWuRx/B7WYBlYFA93GfOQu+LPP2BQZVkOsU62zTEZJqtqnUp741TIQM7v6G0PeO++GcrB/6FoUHd/8/OAdD3d0knqemzjHbDfVrmUqGsxlxuRkHmkjj3yETm5q31adrqr+OMIUn7ns4Q80k9p83zube5UIoOzdw3m84rksi8I1qvsvWrMZmoiwglv37Dko/m7WmXFonBJUVXoX+w6MUCXaj5g8FBB9UjAvdtfUIbRgChSj/ryuia/qzM5jKEWU8V/Q1AoYKrd5QIzwqCmaJdm41Rdeu+GVUHps6DhYek2yUyTgIQ0+lXX0iv+2CnpNUpdWBdX/iKdXz++ZdffvHF5wIrxOQNi1OrGGleW+fMlxQfA/jRPk4miLjt3DEk9xml2lgees6Mu/AsqCepqtnLwfXfNmG34LMv9DzVximZ1HaVBbtqNtdv8ftNKw356rYQi3g2OPz8i78OvvprlytogPtpVuHoMNW9K+A4U+kzyaa08jaUtZ+Z2j/uqH2BP3AHFGvqpoatM5l3Osnnz/761d+6zaWoqTneMG4Hie1hs3lc8ymtaeD9FhI0UDczBqJCoAvlXFcnuEowfCYvasaDCcwQHR9Ohq0XRYtRwsfFBGWQbELy9eHREf6vz59tkwKAlMmaWwDv5a0Vzg3D57B+xiBl0Pl6d5pXKXGAuqINSa5pAbHZ+8w6m2npRglFCdHrA2JxDJHx4QSkCZUgwgCycMZdFsi4K6gl73bDMXkMnmF4rwQGHoiKu5d7llLI6TUmKVP//oDv0n+xhIHt1tnOGW0kDdFYp0iFFUJGAyRoHdPosNmI35Y01MWsr/X7miIY0Uyolt3uAxV8BiYUBN4/k6m9Fanxp7fzaGlhL1XsdkElK/8JZ9ceO79xUHlBA+w84QgHXmL8lm0BME/QIAwX1OPw9X0frV8JB/efK3VHPpXL9JKds5ZI6qKIbJlVGipCSZBWTgDgXHU3gA4ltnfuepR68Dl1nyiHWc0wKkSG1RFiMmGkthi6xL2aDA8Pu2vDp65ER2vIdTew6qG1SkEvH/1zTtGS+q+imwEzhIdZt9tZ0yQDQ5ChTK/bSWZpiuAaZaIaLNG63t6eOyKcep8Oh9MjVLoJbytnMdPJcNUniqebxBByH65oUsGVnSyc9tDKXVYxSzrGl0x1PEOaZ60YNS65Z5odCuFjJlNTqgS8M2PZFdO6FXCZjacTO5oDtKsG0IpZ8jfLUBRE6/krJwlbuY6my5BmTmIiAtNIt2uPJzdb+YXoWYtBLyX/Tg6/ahR1u3K6WQ0Z2UOrSpu5eTKA0wFImz0efvXXv/71mRxarbPGg3a3ngTTv8SOglzBNRoM10f20nzd64E7mlTjdQ3r4WENgA635EdIgN2uPCXEHbB36P3iLuK1Nu+2sXka2+35HmpRgVjRIPP8HpnYMXnlYYSBzHtfRFSA1KvyeZp5zk/NLgZpYQzRSua/pOjpv9Nk/O900gNp0u+Bz57WNPCYasfWOJWGvfFgUpvMlRvIJTVEcSzf+eLjZxNzIzaOY4gdk8iHhuA7gKE0rRuEhRAuN6W29dpOThpQxRt0qB9cntL65YZ7u0vpwSF0JDbo8ghV4uoKojZd89Wa25+KYWJl0LClcuclxqfSoiDfB3aK5PfXvtAxgA0pJOv7BS05xKsgSlyxJXOeYoI+GUsJrFEzZWaJVTqeQPe0pgO9WvlFo396T1TwMRTnQP2Vcc50oXFkS4vRDU0KJUNDe8CtUckvlrK/X+TydvVptb4qi6npQY+XlWWjxLUA0c3mW7aFK29UaS6Sf0kvVr0YAyEludcodd7ghnANSziFKzhT2L4Y2ofqsm43yWQ66ulmk0zRt0zdaOYC+QiANyhvbukdyt19mvs15J4uVTzQlco2X3S7yRIlC1QlxwK+Rma8QgshM8I1Wm8244nlj7dSgFGy5lofJQAv0WB4eWR+Dy8NBzxGVbIeX07g5wB+QMei4xN0PH42gedqwGM5yDMAL9C5+HqNzsXBfmdy3Z6aoElNvg6/7H7QFOyL9BSduPTmMJX//C19h062t+PLCdLi5wdIqvRC4dc1JPT/z96bcLdtQwuDf0Vm+1jiE6JItrOUKqpx4qRJm8Rpti56+jKMBFlsaFAFITuOpf8+Bxc7SclOm/e+N3Pm9DSmsC8XwN0ve56zfJ7T2QuVYnTADOvvFa5UXMmnm01BCpi/nM1Lb+6FmTusjJp/0Zj/EamSQs5/Hw1fwogkVp32tR5BeiTnTCVowVCO5NyXvFy+MEdBXZwvSJKRTI6jKRG1ERHlKjIV/5CrxRXyCpVd6xsSQkNyWYBNNha9bLoqAE74jBDyCzfta+vOECmW5YKEPYUlQ1AZwxjSa7JeB5Z2wAlCZr2gOzGKplH3D97tpj/zjU/EwVh+Bo+m2t6b6hg8yRzhZRwnYk0MjoHwV7yNvVuY6qtZrMlXuo/PGxfwqX/hXtZvWe7fsqW7ZS/CS/ZTmVwge9G+DO7ZM3UIPugb9oW7Xm9+rS7V2m+5Wef/5Fqd/vtr9U1IPYIVuZ45zg26XGkDgxMO4ZkC/EgCvmVA7OXoipMSULNRVlOuVsm47LEKpSbzYXmmNK8jExrD0rPDVRyHyNYKc61RwEmmRyXpK9NDDsizivLnUNKC9IfFDzrVHJ3CXDVTUpka40JeuEPZsvBUlvFUHv2pvH2n8mZo0Qv96DHfnHJrf1j+wHoaoloURWzeuJzgjLwCTNZhrjhZkrxnbzmcTEneUxcgGk27URp1l+kSKbVRrWC1InToYmdKfNBkxXGirWNXRGv4SALN0rEqEFhSrdcc+71maEh7s7xalhWEYxibUSvsupwQJS6e4qVbj1dlzfWqvSq5s+9ya+bB41NvJSFiq/vtAm0Z7yMePxjnTcID9G8CrgKuNHB672JZY/3t+QKROmEgz0Lw6OGKZCNzTLTKBLdfSYZzlObDSj8E1ciPww1ncWjId3uiVNF8tArhkOESV5ijdNXQqmfgfHsDfrozOGBQMqRLGvNyPHnbNR+VENWwyKoKDCfT0pAqNmkDlGC9/cO2dTOAvn19TrgSoEsSyZrpShpawq1dqKFdfMAv9ApBiIYuyfSVkBO7nFXbcoLHitfybYUgQDlKjXtXm2iXsD67+7tm14SJjOQ7YCLHJUrLocdDqqiwrEHZdIY2SZP2P9g3sDrK6+x6O2p9Oe314VC+VHwzhULgo5L8yZN3FOEX8PUXRfgEvn4VnnHmcUMI1GHkI5WY81VuXniw9VyWCcevaSIQsgSY4lgKpccZsGj/ck+NwdTBEQx5R3tvnrw6+e3908fvX5y8ef/45O2LY+3eBKKt/AEeeEGl3+etWFMi6FPCj7daCdM4z6Benvbe6wCd4BRQ1ZbvjYEyw2w1l0Sm74ajUmHKL/Tfk9Jw/lVwaPAfMqNzG/O2enD5C70cZ8Bcqhyn7r0tMNbBRZsxx1eg9ddaljyXK1khSWUQ8rIcaV7pagOqqTD8utl5HCdcO3XeI0lJthRDPWeaHsdJKBt26ycneQYKCy44aulVRT/eGmwSjtZrZd5OCCmDlrlqI6/k8420iK8IpmvNKIJea0vrNstSLXcG+30NfVsmaRi/xmAZK6guDOyqWhscLH4xIS/LRtJzxfK9ZmgWZTg0sDhi6TYwtEYWf9AkYFU9L31/qNeIsO4M9tN6sAUnITDxhlQbXNfpp55IXgxDURikJXCGmcSCUE34Vc/H+nNgix7coKj53Je1tN586jAqR0dyhHPSH+Y/8GHe7aJynE+IrptPnCdRepEoNEFHFxZ4lYzVcZngEiGkgnLqkJ2iJyEiuPkH/f3Df76QIkG1Zdy1hDdcvn+2dF+ybEKvllHQScrrF2q/f3g/ZaoxlS3HF5S4czdlRDdhvUjADaZII0JYS4BTtl4PDgb9e/ZuX69bAp7KQ35iHO+t14kpS1RdhN2bM3pZpp6G2zv/WBG6k1s9dO6FxXotfrQQAJrF9tetAcLihz7yrFeNs66xsFc9bxPtKxT9cal0bT7zXlMPSm7is1L+61EgT2pSQDGqStCz3yKNSmlNlH0pu9y34rlQsgX+wmyGp/gvc9TK+iF7gYUMsrMDzIwj9ma5t3bM4kcbHm1EFfObySHa4OR9uBit2p7eMq/arYGsWC6ToNpAaQZ99tEgT32sxqX2rqe/wywVPLXcGZTeCOkMJmBD09eC0leWnCYCVw6RA8VdhiFChSQKSSm/NYVIclw5IZIx+K9IhiuAomM6185VCMdVLTb9DcJWqy6bbmGVA7bxBNtYglDQmUV0ctaB6FJyz64cD85ySOCnGPucsxs4RL7BkPXKbB+zHaSAQcLwdaXmgEVtwH7psfiywYtdMXF94pY3FfCZVgTtVItyVcw6H2jH4E2aQ1KS81JZMYQbr41nQZzZnzSF9IaP5DEYMmL1powuqxzgej2eYKAp8WeIjfqMAyHbMw7BPK/RWUDFOJL0iazSrwn1ccROb51TXsmrGzPRm6uQPfSi82uZZPDxC8iOKxVg/LlA+Nfdx85RsdsOXNl7L1eKCKy/XtE5YfKHXRvC5U9aHNM50YU8CbREFXqLsoIFgppKm/IYlClLbtozyyNb+/IjWJRTYAZv980soYTJlVXQKUep3ZPByLfqUtwgcvyNrgjtYmnX+H4vtwzu64whuCx3h9h3m9ublqwSfCUH/2WHd9b04+tm94rOTYFEQutuD8C0XtWWAc/nYpP85dPgP9UZaKD+YhLhOfqtvEFAdAX51N8J61lxlomMMJPlozmeveQNfIrrm+Y6uHWdfiXopP8DoDMYg0KYnm4diXUcQPxREP8Ia62aPRHHdIgEAV1HTIlhsdtXaKTno2IkNObGdNCyfxN3oD7cAEScqxD6I+kPqfEVIsi70ttqTNFQIrHOmAC0GnZEhwh8tYR9julEuVTztNR/8dQJOqyXCZFNF2/Kdz5m/Yoqr18I2xDnyofjDfZUTfOaq6ZtZb5w8RumI1tIzraiiVivrzahm16lg5JwzCSZ0NKXNR9p4CaOs8m0D60QsIfleh04B/1bQHTzHBgZvwpkOGnWBV+OOTbWK63DzOzzKqmeLByvKtPie7pnTQG2+g9UdQOrAdmLsokIgGQvCiI844xQZz6V6WOVExuDRglid6o2aW/BCScCxbFagD1C+HqdcJJbJYCylQ70DvPb0oSpb7PVyOEEaNfuexCMe08phWmt9iurpj64a31GG2wX+FlyXw2Fq0a3vQDoVXBrKeuNSDtzTA5jpllRsmvN4zLY1GNFlR9iZgj0Q9+du73mhoj3nLRYVuDEkKSbTdIPLMjhBt+AU/ktJHOJ8BNJ4PIf+6N8zG8NJkouWiKcXXdp1IJy1YLPfAEwypr/CBRx1XoFG84rVXCCHLwKnJHki4AVjTmpJvgxgBrSngjBZbgHqQCIJc62rXIGjIlMr3UJa13atc4aS6knsD3c3+753jAsUONBEnHcfJPCSBRUhA6Rt7Zlhjuyj5GJCBHE6PmzrFk8/SITlCnRVjyuFYc7rwFpLYaNSfkC/I1rnlALKa0buQxwi765y/UfFfmfAsj+Y9Kehmg+yNGueXWBStNFv0q39mBuD+20R5LB/v3YG4C6ZL/stT/L+MfHJX8YRgFBV8xf52tA0gcONYiY3LrTqAMaNjW344ZF4jUAskpDyWuGwpD2PtDTHNSV4CNRMrjPvNc0KA0GbiQY4NFBaTvNkjraF5qe+qMzHQR2qdtXRuIY163NmhxeG6QlOG++ysN6nbRnAOC3Z6kHsu5qfStBqU7uyP+hd9zO3USnqF8AcdyerusnW3LNZQpNqwvdvxB3g+FjXp4dqctmy1TUtfQsAOgtr8bWvsy7XO/J8+PbmFfz8X2zyCtlaJtXnazgNJtddlTTytNFy+sbzIS2j6qOLbSPT7XxpaNSqnHFpRyeWNDO0XJZ5Io99IrO3QgbjwFtBIcL7aLAb7RKUlHddjHXPJpjC2uNGxnmO8VgU2JdwjCv8b+aLNEttE79kbQMypDgUQ79bdeGo0Hn7styQA0mi8Ejyw24TLriKzq/MS+ubSj/hh8nNskR87bxj+Y2/u5t4+87eEH6XPpIhOYDbXGy2x5j1srPBIi62nU25Al3XgIcl9rrFu/tuR/gOdRTdbEZmoAwhnB9LZqngSEcMM4a4RBpHsrzfJtXZWFsyBMN3tosze2WYyfUQWjE7WfKw03dgPoJC1VN3tWb9ixCQV+lv3/Yr1d61qhk+e6Na+RpUdDTrOjAI5d25DXSsf7DOvOSw68OXPadqOsb4Yu8dtpYnjidJAVXLL8GN51R2b+gfogBz2NXXUNzK6Zv2mlR6mwPDNnuPkntuVLiBvV4TsLmQ41UBjrdIKd2etNhBV/9lGK+hZkiD74cc6srmbYKbzQUHbHpouTb2F+1Yfu6sjcbr5A3SWv3n3ZEZK11Kwt7TLZrumQNR9SafwAkRq1TZwHfH7IfRGBitGtaYzZpxRXkPjQD6vv9hM16Im7aBBZfzk2R9vgmfEXesHxg98WwGJcTzFvxp8aj59lbDYWztRJGWZgROhaTxgi98TONE9i80MSM1dFvD9v7p5uim4DuW7ZEaRQ3+Jitx15rH2vxRkszPxXlh6z4141V1Nwr5ulvNFm/j5xq5u4GrexzC+fWu5VKAiYlOeHjwUQrqOoA0H7HTppKcY4ZLjUJUNvisFjZHOADpSYNrjGesnnZGOC2KYHSb6N0faRWYRhkEa1AaLO39QQquM2etq2M0thVpVp7tAVQneN0Xn409/9zKhblrNGrPGlaAYq27XfL5dkYILy/Lf1nLD+rhTVuvOnGLsQUlhQCKztFyU5dfBg624saqA/Pm5q79KJTumR41cutr7p1IAI4rNLwBL0Uw31aaua0/vmhLEUleLa00oTKShQlIcDtN9wUz+BgUl6BRomfQ2fWX6uR5MFVh9svSaVxiVmgMOppB4peXY0UaS/dzRzw020DmjrtTj4ZHva/v2t0rtdrp0E25uCCc8y1AqhSjwP66CY4daACvROdrilK903MRxu3+zBmI74mg3Q/lkX4mhyCIiCs3VU70qxVtblCnm8kW1Xo525+HGix1uDm68hVrSRfM6ZeKQpju6zXjufzTWitaxg0lpTfweB/s6AddtpRE+9ArGEj3oKV81UQUDcCl1+G6FduvEzbPUvbeyejj7e90PogKE9Xr6nAxuqoAeUSXZHUj1Kl9AqMy4lPD+WhznkJNFMex/keIS9LYweT++qWwxZ9zGy9Bv+rSY7W6yTT92mOMJfvRZLLE6OPzJY7otUHjTldiYomeEOGXqNpx5zbJAjnOfmT+15CNghnkPaJIVzB1yOG8Aq+XjCEC/g6YghP4euEIbzMjXXFPNfWFe5mXuR162Wj8j6GBc6stdoUBELWEUaSjadgBluMl+P+xGq531cWidOGWe4SaBptLFi30FWJykjXmcnO9SBWdhALFVNAO7NVxrcDZ2G7MHa40J6zw12NF56m3AzmvCaDuwf3D/XU5eQLPPfI0Fl9ZSq3Nspce0qKurn2khS+ufY8LHH5dFYNV+t1sgIGbbVeJ4pVm5OPNMnVJbogyzLJ8GualOi/wB9BmwXs1zF/nTbMX+e++euybv5q3CA0vAxUDfvXytm/rqz9q7L5Nyam+k0ptYVFrmwoFpsvNDs9zwPm0gf103O8k7e4SHOeslYSMIaIeQJj1dBFnpgknAH0gKt0M3yrvm4TQI/d87kTMI8u4JdpT3vnMnYWP96gYVBXqVmAIifuVghJzUA0QEeMBiqX1AIbgxENnMFJr1p9qKY8/0CTM3+Ynnpn6cw4Ud2KUwRWnHxC8t6K2SaVy8bcxXr0XATl/9S080Owtsn9wff7/mJyD/u6iXWL23Fvjxg2W2F2wFlx1MfbUHcpa+Yced2cgzfMOXjy0NxfZZtJRz0fez9bTDuuKe7/bDXzyLSZR45wRfrD6occXERl42pCvLqVY3jxuqlHZk09di8p2HvoRh429sDaf1jLD2f0AOYfngee/B/shER3eIuF0nX70Vbmmj25QZUb7IujTW6+N4xeJNy3XuK+9VIG1kvgHygnvlfoh8GC5vPEUhFKn2MLrXHfOoGzW6XsKjVWOLRe4qAVF6wuI9yZTGaEkGkO1MpesifWa89hU2CzihAWcTzw2mRAAhIDR8jzLUaH1VBh4qhmk5nn1iwqTz7lSQV3k97DzGbaHGcXDCWqPG1IdKodHh91w6vc8xBZ7fB2pYoXeQoPQV2cgLY2Ykr49lNT2+mfZWOqy1zZpM5toT9KWcLBojI+TdjIjSPwLuGSa54okDZgtWjZMzncVYvApFivk4JcGaon/SAHuUIbXGkJjFdpQgqEC0shbTaMrAADAaXXSh4So3iIDz0oUab0ipExJbnSXDA8AyD6NDTi97kd2HSPkPf5el0S+Xc0TXU9Y23R3oDvjO9THnDzVLwT3uLsLAByF4mFEzrkAQLD0RA5nbZh06nEo7zhV05hIIH8KjPyq/rzXx/KfpwFzmsz57xW2Q2brRgz51iBK0e7E1LiO/uH+/e9znOSr9dXG21w/5b1VuyCZ8vAQzALXfzyCRrm9eZD+mUCN+VjllS4BPe8+557Xstb2dEDKXHueY3KAw09TwcxFsgno62UEHPSt1R0i88O5asj9/0f7mVxnOt1FXH8MQcvAjYFS4wO9wlJck+lMYZoJGWX5J5/OjTM5J2YmU2S8Jp5vuwyr+wQZb06DSG7Tzh5k4OPBoE5Qtg5a/TdvuRtDksCJ3rD8geyzY+evyK+hLWcDM20WWMhmFqI2pTbvKnkdRcV2ts/eHdxOIIVi8r35jMYIHm++pX4a9A/vH/n3l05HAhlcGewD46s8x47BUmRpZVykSC83//+3uAOMNPqJbTr+AThw8H3hwf9Q9vmvbv3wzbledMN3j+4f/9u/37QIGiO2NYMR0YVsEyVJHBH/SqvM0DNoofk4tC5EwYvwUMnBw/UZYeeSYGvfuu2m/luE9V5IBz2/e69Qf/+/buHcVLffGTg9s7B3fv3+t8P9u25iJNcBSvuzfNCUP50FgsE7mlqqTHEZCiR3M3jnIvLBOG9ZOAaKrs++PzgC8rj2I4tOGrBeDyt4nXj/G2ARXa4P7h3b/9+XLsy4MJQS9F04OodiaFr4YuWqGXm9cPiOcoJqKnH9XcIHiilbeVcO2mfcPk8seskQt6fpSI1bJTkpewn96hK7zvYCayjUWNQENdHtuVVsi8+vI1uqYSHXEKnW9zkht1Q98qhIetxWlGRlA53zIgubx8dXEk8U7kdzXy3oxq7ycarCZ7W/OcVpjpwtQ0xMiU6AnPNnR5hspP+ho8LR7CT6aaKYwmuIp9fnuj4FFXiH/OXAeruooOKYf4DYWCybz2UOqjKJxBgLOQTjXkvn02cUx15chQ770i9DhVC2HtqsgZ2CjhCPbHlzpHImT698kR7v7TDE0BQlG+uRL9gN2whjhMFf90BzoPXT9lD5F3iJ3p+abOaX9qCrHYbayivv4Xv9VfzYIvxdILnJC+TJRrO43iuvLO8zJMl7uNlG4yCI2fFZVxtN7XI58nC8zi8aPQ9I4vxdDJ8mScz3MezrT1trl/Wvdqy1lfOhW+1wHhkUV4LRAw13OE6EuZ6T/n9JrG1q1KdeG8Wt2RSSLJf44LYeKzy9a3aryi3GC9C/N/zUsfj+Ex7bqs5eZa70+754MS25j2+lkPgu5EoyaCOiXKwqagJAhS71XiErckErpcFjMvJ5r+FCb7/dZjgV5sGF7zvc8GvNnU2uPC54H3HBechF/x+m6vdkAXuvCxeLTlVy9efbG7E9z7O6+4Wfe9rpPRVrlhPdtJTfSDNhvHgTkFvLu91Xz0K7HeunJ5hyn0fXAHfXZ9qOqK+V7ooQl3jas3zPtRKMfRxTvo4I31ckb58VHGhNL+n6s9SvrVz+c9CJcxIfzhzSkUzc9WdEzFWz9W5O4lkhs81BkEKfB6QeqTE5z4Pm+T4PAgtQKY4W5Nz9Q7glfysu/Q9N8+bGsMlsQnDyzoXhBSjYhuHJNVCbG3uqPyOXQbsFdJo0Fub87a3F0Z8g+cXcNYneVLgcyycUWGX2PUyz4V8Ls9r4ga8N43jg/jcIl8Lci7JoP39Q5OIrpbrdbIke328dQVIuAJbyyGviWB5ttcAwD8loCgM7A8zrKEkqUGKcG6jV5xu36Txnzw5d/IZYPGgCTlPk/l6nczD6QVju+nctk1uW88In8ax117DVQc5h80tRkkRGEMaoC4aDAA/r+Ui3XkI4rgVDrc2dBPYRKk3pHMP4fixjwpyjt/lyTkCJ93nyAtbXMTxjBBSeKRGEbA+4LyekcLQKWdxnJwFa+SvGD5rn0Pr1BCekqQgZyiO3+VJgUZFcK2khQl1f6XdyJk3V1OJaYaNRZ36XeHmwqQr6zARELpUNMPjsfX6J16Pjsch0XcC7FvgKrrBMMTHzLmBCUM5AdZoHj7jGFldDOpXjps+o9KF95C887XHTRgtdQrjWFmPEhqEavB8VdVwKeEgsMkjl0+CcZfT5shqq0r8a6USb+xGOqbBqnORi0W5EqAaX3UyTjusFJ2sKMoLUKuDLlv6imNLXrRl6+lfN6BnWSU6EkKUan4572R2bJ1pxr4TKryfIU/ASqjCnUw4NX7vXER7EVwS6sq2RLSK9pPIp12bUCB07dDkH3eh3bawqFeKUWUw9YG6SITl3MQDrjol72Sgz757tEooDtgS7GudFxHHyR5V8YlAdcQC1vUT0FhXBy633aOe2YN27WBbeBTXwx3YdvvjgE1V4xDlslPQc1qorGv31me9Wn9HI+qVpF6JlN0aDG2Qeh2WtZRnq52Z+2N57WRcYbl0ALcFzWZVp1yJKldQrGU1O+fi+Yhr8Hg/g/lJWQrsUGIc4roP8qTEHsdHYrp/50mJsEe2vq3dLrJdv0nnkE74DXPMMIPmQsd6j+sDxTlpEWn6ztydHb51A1wzrTVOt3RqAu6Ia0WxW5BSrsN2NCHwjfe5RZzuSMsy4B8gnJGy5937I7+kl65dVet3b0bnaWkpQ9zivUJTTD7HOeV46lOedhbu+azSHCtDpsEBvKEpxWY1UoGt0Cf1R+k/Ygh7Ki5phm0U4vTWwIO9BxZCPFgiAlNjTe4HQP47t0Y5Q4jcB/q6uwIXNlmeNa5GTe4EXEx1ERi50xbGsmbQg5ylTd5RGoF8yLx0WjR5zde5kt3pGAA5wiuPRWyt8nKfRVyQ8zLJt4j0hyvnUC4ITwyWCQWu0OajikWW40oC31UY862qhUxYhbBVj2zTNM8Da9ccmUjBjh2Ye2LPoE0CnrZynKF6GCeiafU8yLgz2E+dSpHThLF6LklG+LicoPUatMdzoz2eZJ5gHNTfcrQJXc3eTf0yl7pMWOTg/qHXRdDoqWkUKzrJzvlBrjht+XUyYpxZ1pf3GQav0tO/qyc/2L8vR620AU2AZq+8edx1afOSpkoj5g0Lvay/MEuODQxv5ExJtvld5vyR9x5aezuwJ0OYZwnFEsL37975fh/v371/eHDn8M5d7PPbfoVD/Kf8F3/mvTqqnVA8QJhmuovA94BXwV7XUNyOqFacWm8M399zI/gJRmBjzdpg7DG5tW+qrMk+eC/V6QcY4rv38f6duwjvGny/NnjrmUEvj9kEbIVOWJsSCAJ97N+5i+8M9tEQ5OVaCLpOxEiLTyX22LoO/do61Hu2Gx50jaEbLRqFII1/Gdnsvbv3ERppCSt0a+LWmgPsrW+42Gq57t29j+XZ9Hb/t6aKsQ4dhReOhgHXwE3lQKOTrKrcPHTs9S0p1WvR4NIsyN7ABhn6sR/HT03YSIaAQbPXR3j+48BmDFRoZpOxbzP2celnHNiMA5z7GYc24xBnfsYdm3EHV37GXZtxF6/8jHs24x4u/Iz7NuM+nvoZ39uM7/HSZSw2W1euJha46UoDE9ItN54RK3HJ58lMrjQNVnoOA5nJlabBSpuMfZuhV9pkHNgMvdIm49Bm6JU2GXdshl5pk3HXZuiVNhn3bIZeaZNx32bolTYZ39sMvdIqY245sD7DeQgLkpx3yV95wvACtCnVYuhEjiHUmV4InVjiBahAqkXQiTlejA9U4qFNzPBifKgS79jECi/Gd1TiXZu4wovxXZV4zyYWeDG+pxLv28QpXozvq8TvbeISL8bfT7RXukuyK0pzLSiHsuK7xOdWPDa/DirVC/2FkNmQQOEFmbunGGzjzk1ot8vmlWFui0u5ZTpeu4ZhsB46J6BLNlfJ+BwhfCk3UhfVUF0vOsBcF923RTWc14vu41IXPbBFNeTXix7gXBc9tEX1WagXPcSZLnrHFtWno170Dq500bu2qD4v9aJ38UoXvWeL6hNUL3oPF7rofVtUn6l60ft4qot+b4vqU1Yv+j1eQtHzOF6Axo/RBDhH+O6dOwd3HZvhuXmcRaDloqoZlaW7+4NDj3kiM49LeI0ThGfXAWwbQvePnzB4u/CMzHdfrIttF+ti28W62HaxLrZdrIttF+ti28W62HaxLrZdrIttF6t+wszF+rZxvi+3kmghOnGwn1565PvcEu7qdr4c9yeEmWv5cjyYEG7u48vx/oSU5iK+HB9MSG5u4Mvx4YRk5uq9HN+ZkMrcuZfjuxOyMpft5fgeaOqqW/ZyfH9CpuZ6vRx/PyHLgDy4e5hekquNHd583DcapN4w5+OBSfWGOx/vW21TN+z5+MCkesOfjw9NqjeN+fiOSfWmMx/fNanetObjeybVm958fN+ketOcj783qeF05WFR4ikbkGVmEcFLctoTPGPVvORnCavRl2Eur0UIruXWIggfNvPrZGpbCZyFe9VeBodxPe5tK4VXtRBZW8vhIij5/a6SeFoLv7K7MF6izeZc2ZSQS/NK78IdjTo8sDyjFeM0my6yDwWNlNlLK5GQ1s23/xkV4Kt77A3atIw1JlxiJgl8UObd6ztjnY0R/u/CgP1evKu5lF2q4C+2y7zbRfrmylUIGFC/k106VduMRBHwrFoqZwo9HOcTzCGCTBZikd1M64d/MdZV4cxTSgrmvQPH8ufexKpKwh1Wlcv1MGwGbZLjAvp0u0i/4hVm4woWJpcPeaYecm5zgHWkB5PFcRk86dlNn/Ry15NeBk96Hq7GjR/wrw8XzXetuvm7VhFWeznk8Cr5erSMphpL+DJPyTiftF3DBWHj/gRPCetVEAFmgIYVKdz1oe2oCrxKpghtMn1xVE1Au/6a8BgMfzoesWLpylU61AKXx4EeonGqE3B4meHwcq1xX43ZRLXBfeZrqW090E6dwhI5xVG5jqW/jnrnSrmC1gLkYB/zMskwRRulldsnBPp2InQJAKxLeKAz6FbglxYrbhef+wtZLFsYI0NghgiHSSomiHAYpGJ+CIc5KqaHcBijYnYIhykqJodwGKJibgiHGSqmhnAYoWJmCIcJKiaGcBhg/SFxS9F4SEJjYOYbAesGOWZjPjFtIrw3cMv+szNvaWiAa+VvJdp7wJ0nRfADpLUA6+c3UhLLqGu0pvNZNwLxOLQWbSmgM40egLHXseP8NtdOMffAfa4tAXY5mnOp7R4cQ9EmALfQxPEKzJhR3W+W74HV86FVs32eJGi4V3PXObhrh6VPcg4GFH7AAbH93LE4TiBqF3NuqtE2j6dUeb+gyJNL+t604nib25u6BjDW94l/hfiq4WwytCaWo/bOEnOnhFKqdP+6eu+CevIhR6kT5nMj+HDSc24VRB7rqi5+CqyGlq81+0uQ45EP9u8rs9c/8lZ3e2NaFxKQ/oREtbQIQ8HQB/FAlguS2oq9DP3h7zcqhQW8Jix3nByYSjaprVitp8NGpbaejBuUOxMS6e8I001ytfH8kfzedJIZyPxYy9Nlrqjg6fK8FRjhJJ8MbTsmYK3IFJjxusRJoFQ+Nl6F8M3hXVJueXPg4mjOwcr8/uUc/KbKmjWBDjbNrwkAkZH+MPvB+M8fZvJSz5J8nE2w0OpuSsvFdnPjyYva5OFwGKxLaCyrIZ2CtZY3MLBhBvvwK2ZoBAKy9C7YtLFWOVgIaqG09JrCYa8Supr9ifYWLaRvHflP20a+5ZBc08+1I2/01xy5PnUpvHr13sJrKAX1Am9fdZNXGrjx73XPKCBWczHkGlatcd1qLWbI6Wu3vCAaSdxuXAT+iZx5q/m0tiBtmgiZj1S4sKhgtBZyIQbpzypxkwXWsbIj7zdbr5s2K8qbXUb2Bu5my7OEtgR1fJsnVQbmqGVo7P2eIcDEICS4W+as1oxGm5t1K6LbBbvlTFJ80NyKnGYJt5Thsyx5k2kEDL/NlQLSWKKG+cTrtsqa2js18/ZjjnBWTyyE82GkbdpTgU2RlGKNrkgESAEexyYM5QkH7c4S21jlaY5rCkspc5o4rK69ZDWqEKacl/wJ6JryNPPgepXV9b1Os4S1L88zszyKFcL9BSq8dowxEVlkOoby9qCHNe3r9Rq6x0G/j/1+WdjvtNmv9bbY9N7bTNkbYObJdSUptMx6Vf6Zjq4WWXVyTjnPlSLwIquO6ZLTaSbozGWwTarc4mm/bm3u0dQTt1TLQfVchwf3D/tGiTKOOSgw7fUxI2y9Blctuq8HdJGd5yVH4BTPxPdu62eeNZMBYstGrG0X9ZtAbKLr+94gfOMlQYA3Ssy8vYiLaOy3OEp2+d5tuM4TPm7tXOOJCWD93AYy6n9/14To1FtgwG1YuoLk1sH9Q4uUrzVqoX3mkGWZlMrNjnG7Q0r1FzRB5wpmfuz7qn2vYbP1fqFh2+YI/Vzk4JOP79glZM6n9vTFjfcyPd6EjeRE0z5Srr+WZaKjQdug68pbkAqq3lzOzdBPA4vUUjth9MOn/8kTjiak3GyAOCDURG1Pmv4ef+IbhDBFKd0kHCnLy6XSMHqeLfHcfS7sp3sxZpmEAnka3aHBFGHn1ZAYr4Y6V76xW6Lsb6+0Y83jeF7v3XOVFmB652VyLle8Fvt1R9xXpZm30B0EuqKXWQITh9B/CcJz97mwn55ztEzTyt7tZVzY0GHz5nMHazyRJx5sCAEBp1sRcOoQ8IFBu8E3UIkwi2O4ymzyMgNwLuu3u7xldBRpHw9h2nWMuRM2mr4HN6xGsmbncz3IDXd4ygZuzJh5nuU9N71J3Sl5dzBk9UUJKHqfKTioOWoCwk2uS41X6B49nJsLqTQXUr71QtJqg7i0F1Kuz7e+iEhuLqSN98CfZbs4gMoWuhaMQa8MqGctttTE+/uH8UJTkYrfjHqBtqHzL/ePR/DLVxrBReYxIhRqEYRgwj9ZDMPHLd43q4Xxj/CvrfUetnUHpAf+1q8gp/4pw48y/DrDb7JtXBMdqro/IZH6VPyEMIjUYEKiIEUVqgVz2pdttDBSjHvdA2jF8CbG1DdPAjaH97vJvPiob8RHGaH4dUaE5yeliabp0hrV8xrW7iX8lK3o39PMMlp9BqZirv7KkzfZ+FPmDjv0+VcGCpJI99PQ2wwNt3yr2vEE5+RgmP+Q8dMV2Nb4LPxynN86mBCbJ0m0Jt3GJj6uKUZHGXh9kFha+sJ9Y2ViY91AuJEzpEA/80E/C4zq/UMQvFkv/8FyPW9bLktj/M9YrIPaQj3/twt1FFLzv+V1d4wKGCeYI4uYDUCMwsf9ScoVl0ruoJWvOR7V1UZzoJqilMw8LpUnZxlnE1yQcpxNhvfjyjnuGScLUtUddUEsd07nkoa8FXWTBVn0OF0W2ZQmt8ff/l+T26c4eh8hm3iSYd/rvA0uPJ5ghXk39g8492Ph7569s6NbUZeOB5OeKJ+VF5Q/zCpwCo3QhBxnSYGMhzjrlnKpeHbT7T4q8nkyDUwWLeNk3slZJ0fKXD4pSD6eT9CIbol9v8RzXIA9j8muB2qQ74ri/7WJvpc4MltCou7Pr09e9Cowzs/nl4m+2PeN88eF56PCA6ZfdkESVDzJyO1kfHTrzwm6feou12N4VAS/tOR1i48ALV7t44O+RLqnmZgu3GsSjR+9enXyatJ59GlKl+plXOQF7Qh+mbPTjig7FeV5VuSfKYQ3g/MR+W4KsgaKBAhSw+nSdrGHPRjWdSC3gO5/1/C+MEK0837wVQZ08K8GI1t9l31RoC/nSUHokK4QbqCWRfrIFT+m8zqWVIueo0thTqgkgJWlqXELGDhlzufJnuI+DvdYHHOZmZVgYOccH3oRyZiJEwZRafgXxaA/4Q/Ls6WsuDUsgInWptr3YpJtNYjR8a/lkv73RKn/o9wyxK8cSWF36AR/Nd2C/PeFdq31//UivBqC6I0kglri3ZoXaWiCPqi1d4RsG8x0B0PxQ3uOl+h5L/CiOnmbHZ45Zc7NrL2xIWdrlC4WXcJavCl+nTi8zqHOtqW62tSW6upJtgWCMXUE8/+5hawNDxg99TX8uotYMxHWyMa2Ba3zT4ZUeYulaIg8n40uygz8Hvn2qJks7V1pygdR0jhZjjVhMRljiGlR1a8BQ7LhF+Vse/gYHfhRvysai67KevhInY/S6l9ckkFksfIUzN3bmVYSj5LIqfLA1UBOPU9cDj0tJ8PWySQa4M81eOLwKfU3KxF1WMas9UxYj1BbQsPcGmhmGxHAYDuIHW/NnAbW7Vpn4xsI+YozcmswFG2cL2UDrYp3uxkhJJcToz0Q+iDfUbkAfBNwzfQnvkE4+yEH0z3aGrZS4oDvFEMzZ7nsTvM1O7N8BtpH06wooFhRnp5CjF6sG7ORulaJpJHqIbGeZA1NK4nLCy98CIJATtrbnZ8xDlgAzxoSrE8ZzsmjDGfkdQaRsT9lhA4NVaXGJYubJX6UkRy/zkiGP2WkxJXDm/N5komEovV671GmyWQT7TPcX3NkO0aPtZwrnw3rdUKJ8+DgY+sI4b8V30ouDsVvs9C5rPx9ZccIPgDeZQmwi/TlIef0eCvqeaNYoKHMsD3GrOz5s76ga0EoPZtTgWqhfyA4eSMQtW1ABzFvSUxqDVE2294MhDJvJNWbuFhQpsaas9PjkgWh3lqjFTZqjK7JT1D6kpdneUVNrF3lcUxHM/p8831SV+csE1ktrqRMattET/0ruDQDZbrnDBoSNKE9lon8HCTOaJO8Y6ATtzWIZH15fWWzm0ZSr1eu78/10WN3BYyFM8SJPDDaL5FWG6IXnb9YwhRtztGwBP4BofgJS0ovjErLWHRU1y+MAQtSTxiHaTuOn7BEDuSYJZqTydDN4r/u6hBcEf7T3jy/hK1rDRCBufwrkCQmeRwz/2r7i8UxgwiTKo5pHXrq4W7r0R5dQNYtUTnVCEo1ApzLv8qnZxnHvD4SHoZ4zXFZH0+QT1vihXpRWf/NigTBXeuD8DPbgm7uCsrcBghtMZm3wsNfu+DBZ5ORuiK4OUywBMMyjsv6vJOyl5nq1ZiPeDdKo65IBViX7YyfqqMRtezFdXFb1XB4Czgk3B8OGzFvOKANc1201iZ4mFiq22FDwkQDIBLWm8pqQPKA7eGOEK2tAPnvOx1sAcPtsV/bgr7eEAwqWRX6bdt4Lzzslk1vjzd7gw33Ot66xX502sakt8YdvkHnS1U33z7znbGKtwRkzudJpPjLLnwjbY5HV7dKG/KwhwCjSBr17sG3xNo/ZNOPRCjiwonebxqv2XlWuj50fBDMO2zGi+R9fTth2O/GBgKPvh1/3R0GWCJnD0Lpq1PnTQLYp7B0Kjym4kFan2I9LyqvwOW2GLxl771RBHRqIoTj0po6JQJ4Hw3cYAtip8w3ygxdlRnZ6w8Vu2LBEjS6CtU/048Z1kh7WSpHTplJeeTpR6crkxr4ikoLk/xCT+AVnafTDJdafcvo9KUzlxa2cJ5hUF5xmmKXmXJGbfV8odyFTrVSakh9n2EvOHr60AzHt5tJt9Iv7zK9376PzldZ073n06zu2/Nltknra+mt/6a+qnnrqj7LW1f1cd6yqjxvrupPfMuq/sTrqypTmqv6U962qr/mwap+m//7VW2+HJZkqQn2vbegsQ/t9HW7yF5Jh8+y9AMYy9U38NqmLBVba2jTdOdGaC0BWwMuAwCE1hJcER8ibDE/Ebc7aiO0LdUV9oDHFvXSZME6QBHaSPKL1btvTYcBBLAnew8SoEgDGAltSbRFAwgldS0WU9QDW0L9XzJTU+DHdEke5rjVxs4ulJ8oi/pKL4EKTJubL0IbSU2PXLbQK+tEss0AjbzKN5sEtajsqRRwNtGb8/LM1ziWOH+QYzROMYf4g0Yjo5NrpoGnzonAjVtDybM04nzrS9nq3OG8egUuIHvqw/rfr1KBdc8pw2GDKd9sQD8Swj43H0Bnqd0G0aqae18xXa/f0d6Lt8+ebY93D7eS2CQ/CY/r+LflOtI9IuL4pyzx9S5/1dJkJZKlkO/bePykZPB1p6xHr18/evXm6cmLDsjX007UpUqW/1tGBnfxnxnp418yMsA/Z2Qff5uRA/xHRg7x7xm5g2lF7mJRkXuYVeQ+5hX5HpcVGfRxXpHBAGcVGRy6KSikXTnJzGqBskC/cqp+PynLj9V6XUsg4wlCGk/EzQZQLU1Hw4rj5F80rBtB2FWBpEZDLvUGrXnbsqoviYnzBetxntML15X91daFqYf8hGANvrAxf+rn5ndYf/ek/UZ8aws7Y60F4sKsw5z1Zeh68hNq/diavlWFbX9wN6bjP7JJHCfLKqFjUU2w6OUsV9uOhbqc1Q+GsCpMbg3uec0tqzoRyUciZZKInFfgH9WVnVd1gUlNh5fsIzFm3cFE4eJ0LMZsMkGbaMWUvGvmVLzZ6TE9fw4szMTLt+TURc5m5UUcq7/rdVuZihbzOJb/tuefFuWHrIhj9VcHMa9IH88qcojPKxKxU229dlRF7iBfVo7S2dsz1BZcG6cVuQrZ6+0ozKycgoBr40WZPdPrB3dZVC3KVTEDH9tZUdAZ+FjvZOAqOkJY3oc95SQdpILCr5F1om4LUTYghI4iPaO8ZFHahxRrbRml+5AAOh/pAXwb6Woa/bBiH1l5wX6MNonwYfqDtx7KrVIvr5R7JYpGdNyfpJ6v+otKy2f2waG9m4Pn7yETmbUzGf+cTUbw7/j3bKKkJxYRVLUlfTmicCjHfpoyHNd1nHKwP1xTHITVow9V0hjWSI0nVe2jcVBD94BqXTw0c7w18FqDsnG8e97jrDJPOFQWI9m07n0sJr3ZJcvO8ukzu2uyoY2xWlXNhjLtD1XCzPIwsyb69++ZUWeWt4sDxkdVzVBelhzug16/G/oQeedUwu34l2yCIxC0HmfChMmMEBYkoQSyEbRkKBFX/axKBD5AOGxRwKLgSII9fMq2vGiklW/dJ2kAOrqsEoFGIuQcqxIpC1M5LvFeH6WDoKLP7ZU3X1rnDqf72vLKG6v9tOqHx07Y0u1iEQhfuH9+3oTQMv4zmyjoUlJpT2NtaDajXmjizLLkIo3Un1S0Q4uSRjnt78pjTw5NICO15UjBK/MPxMMqYUgfCrmjHpTKn57uuJkYDNfCeegpwkwJJlTQjK2WLsbe1ufk1kA9KIbPZh8O+aaMkg+Vel66g8kEaZmZ3kSgB55pzlsii2M6ZtUEiu9PJlj+PZggDO2nEVudfaC83kHfVZpMUIJSiA2i3zXTmux8CD+JilqVCNS0bcRMzX6oI8KpaB97JBGEBc8/Uo+ueskRNJZwkjAikKwfxwwWcZkv6XGjmgRkrG4UKJXP4lgC/DhXrphuAsoSjGV5JwpUdwfDHP4+rfDLCh9V+EWFTyp8XOG/Kvy8wu8q/KQi0fv37PRJWYlnEpTev4/ws4q0yl3x24qM+7g/wY8rz1ffbxnqzfOi0IU+Q9jJBxXZ63t0gg/L5Lnl8r2r5IFVa3eiv//MJvgv+B6AxiVgQEi2SOP4pFKBKN9o/yQvs6rCT3XNvJpgDaBxnBxVROAXFUgJnleE4mNd7Ntsgj3H97/qsYn1OvlcrdfLKnknF8pho+aHQy3xX5VsVONmd833WlInz6sxrSbk1gDDrJXI2pE8VYKuZDfTKnkO+yGbarcmeyOLIA2ARAwFgQcXQcwLdeB++C2zYWjEeFFNPAdMQuvFsPGsmrT5gJDpYz7BOSnV4x5e8jlsRfQGInycrSoBSExRlGB6GiH8c5WUWJXKx7ya4H20Acm8v4o+UeP9rq1l276SBwBKv1XJSdVblJV4oLWHw/WytxI1bZsAR3WD1zDbad+TfedfIiwzFpMh7bkQKnCbBCVe0TmnGvOv1+0OJnJBTrYOuDFCf0jlSl4q8hpUDSWweIYc991+V1tbPam8wWsfOjRA/Y0Ot7xwSyLGfDIsg8WO4/B3wuUdq6Zmh/Bn8OCrwz0W8pJxUUj276x1UJJbAy+Z4edVHD+vxmU1wRSX67XL0wW9t+uXqs1dwYtqdFSlR1UcP6ySI4ipn8WxioBACHlejTL1UqrICiuSvKhGx6rGUQUOniS8rNdQS//0PtWTniAd9G+P5HjakOf5bhiu1NuWcgjskD5XobGeGjcFbGTsNU0ChAyUT3eJdZ9pjr0htyIMOuhi0sd9nGGGi1GuJwhaGwpvWa8BPURTtQIkyUdwZGEAUByt13yVCEy9XVEbp2w3dHhY2v0tuCGWq2SpqLM5wJm8QPJ58rwaLydkipc/Wu+4xihxLnOgqyUsl+kknyd7L2ArTDjYo0qNdjgDioEs8MzgTMEKxHHSnqGroc3GzFt2jmUvyXGlTHQTdW+avtQmA0BYuFGLZ0sAXQBPi1+F6C6Qik9FSLIPQe8L4xY395dNAdC5xOKAH+bQ8vGTk9dv3r84OX406WiqkZU6SNYHSlkHdAbBmkTevtAEmeIHck7ndkvtaAw5dlSRqXoH8dTzqFZnIeCcvKhwRo4qg+cRQ/v8Ioeqv3k1ieM95yAMZavEZWljH8Evr1SPR3qtSyIfQ0U1UITpKkHYNZJwzBDej/lIPo+pbk/OaMujsJnnLCuKy6tf5ROk8ASOkJxmLvt0Sl2eb7YG0+TvCmSDoNL4sjL6c+YrQZiPEhgpT/6QRIgcpBwgSgFRSIIn/MsePCSftbcVwuUq6ePfMkl46Cm9rJQKnvqbICzn6F+2f/iUssaPRgfpPiB7v6sFd6iXnMCVTvXcKq2aF3anFdkEuUS3i6/yWUpdUBoBNxs4yUtLzNxFJS+xx5U2nELYEUPprYGJxPdaZNxFz515oQBlE409T/f62HLIdFQlu5omypJb9CDlYa2gRercz3oRH7nXAZ5quLvuQZFF6of/RAYDMIEQw2BQpisz9Vf0NK8Ev0xb/CqwEUtQymAUu8rxEU9QyvFUydJUIMaqHpmXrTRP3m32dJXcGiD8stJavUzFm9/q/KYkTfpOkukcjXiLEpVAKVdOFF9rTzwyCaymvEHstURns9y6TtRNWvqMJN2iwrQBH854+oF7c16u2CyNUq9QXnU4/XuVczpLI9SNOmPZbmMlgXaTT3R2RtdrljZ6ZiOWqhuSjaIojaIuQ91oElmpixemja9a/TS1nzXNlbiS/aTGtYjQnkn6WGSnKs41zoTgVcqxRMYLmaYBSj8RTxmEdtY2kXnwy8R91j+FcgCWY+ZClskz64c2S0vc9sia4yKy6YLqCpW4LHJ2ao6vDSmtmZt1aCxboVEovEJSiuB9JmBHsSY7iml2lJVWfVd1FnbX9VsK72jGOs/Me9vJhBp5L1L9ccI0GrNKOIrjuzHXrPpweBS/qxAuVhBL7101phOfb5SvvOv5PiHJfU3Cek63Vm3+eNzl0HDIoygTky2pAk7mq4ShGsnG6wvRXAZJw+l5d0RpFyRC+FuJ21eyVcz896aC0dZYir6NnW/vNJeFAYEaCok4DJGkWn9xvEWPTbha+Z6kQP2ulcv45bOB7TV6Zb0INku3JgK79GIVqqVpRgUuFfMHSGPz5kEQQfvqAdYA2IElBDRyIeJ4YIQ8IhlgjjZJphz55gk83gaRwKEUgsYxTfaBiZSB/xqH5HB/Q6YrX6wKUjnyvGq09iNJxMgwCtI+UuimillJPy3B+58O1Jl1zrMin3Vmat1m9FOkHPGu1899UnO5pee/M8uRwGD+qeJi0m7U6EmAeQtlM4gIy3knUfXA1a767EYo8iVY7fCnGs7ZacdCYue0FMCRjZDlyT6p2tjaqokSzLrkswCBcTseSGOhrM5X5FnluVDyzvaV95iPJ7iSMLgqKE+pwgzSxUpZrp+vrrVlfu8bM7/PlstXdK4QZ5dtr95aXmGcLHqJJr6jaDNueF9RYY+U0d1o0XAMBuVavIkxnEah6GyrLdyBpJMOtBEZ9KTuyC8ybGsxjgB1PaytrRvrFsf5KnFZyBiJNwr21Ku2Lde4PgbFRbRrkxC+rBIQs3jdau6u2OIL2fPt416JSnH+8YrcGgyroYlSqR5s4lOoYIFPCJmi11Wyj0tN0Wt+O84QrtoFEHEcVmiXUthmFK2n/UpN0dWW3oaKfVDhOVm2Nznakq6EGUv1JicFmXuMzNH7KoHf476W88nNzL64C82oWeoPtDGTGqhJKc7FoypRXAEE0dS0OM9iNeOqkTQZfqrG3e5qQipckNloYUnp8SwQgEJ/BXlfJRVylDcpgIunfyQFuZD5KI7vD77fj013xnMJZH+qxqtbtyYIDas43iuGliUoG6jIQ2hgva4IISyQXlWebHa97u8RMoWIm2YPEdbdbyqi2E0KEvtYNBibO2VlIHgaBvxtSX0PDY4Do/GY2z+S37KRqDX2460B+El7IylylAoPJiBdaKCA9UbaG4Q2ixyKON4DHnociz1C6BC9AsJekI+aFyB/r9fK12IcQ9mNIEx7MVdM/oP9UFnaanw0VcwwGzJCcYvYHwRQ67WSS5HxBG2MRay6I7RCCcKinRES+k63jXryOmjc+6070S0L2a8V22FjWedN6yzjHx+XHMhj/4rda5dWUC2oMGifWqtDbPA/TVkObUYN2QMJQsTL0rxJEcKwn7yaIDUHQp5V2h5D/pKUopZUJS2LwQndIMx69mX2jXwzwHO5FlqZFp9VG4Q2/gtRt8aTr0LDGM++XzG59X3dDEPhp9vrrMn9RieeIzKv3kq/Xfotrlv8ha7Jtm3YZ5DMSeQV0G+LZILcbrPZ1YOayZvyXf2h89vf8hbStoV8zMuzI4XsNJbHQ4LaR1GvSGs1qTZFuFxtM0VAoesfkA4aw+5FXmFr765tE3aYFGhBqUWrjCFCC1j6OlSKBicGlY7eXC5pZ5lVFZ2BJyaFmNpWQVmzk4vOrKSVYw5/x05tkWM6/66j7Wcue2A+Huau16CEicCP88UqqedrzBl0PT/7up6nHrU29pzlgBosouB49oJZfJABggNXzZUcDzAuQMxk6CnFytggRxnK9s5WcK4XNIlenZy8ef/w5MWbR7+/ef/m5JdHLyJ85byJpnBZRNio1DaRzNkq+Z0mH1YIbTYIf3Atv3745NHx22ePXv2jZjn9e0UrccTys0zmPObZGQW3AIlSfIPuLrbCnefOfpv5C3Pk/jGdE4G9BGUSoxTMWM/wvIiwn9W4L19AzGBrgQtpOG8VuCitAXI7Qi9Chz7LlWjxjqIbOrU3kxt0T9X5xw59gv410+rLBqAr3WAEO62DamISG0tLIlK4InzEG97S09MKr0g2Skr1pJudkcRATqpW3mpz/EbPQ244Wq+fVmiU1wy1S/x7hTQvkvxeNfNRWkt68Tr5vcIlkrUSUDEtCI/jvaw+jbMVSmer5HpgR3hK/pQIcm1Wq+umhMUqCWXBjsfcth4le7mqFqPDdB8Np+OymhCubJXVqJXkWJEbeI4X5O8qmWoRo3zv8nlihTxOxjNv2ekXoHigZVdDIx77pUr6+AALb6x/VsnTCiclYU4g1mOnL3l+ngl6nIlsvU7KMIWoWZeYOdn8MZ1XmGkdIfi0fCaEdH/e9DF3Cv4g/st9ggAcdEPrL1cfinwax+5bIj2BUgAZswmEWuvjlv1CuPDZknCbL9sMK71H7e8sUSow+NYAR64nj2WnAEV+zktOOxm77BjPcFHA2/07S15UeK+PoyWn53m5qk74S2v+6DMBO1anccttgp9U+Mq/Bwbaj/dRtTFkwju5ls+rsagm5B3odeNQ4K04v8DyJQI/qAzb8CigyIYQVqz//Z2Yo1GYRegPPwwO13KHYr4epP7CyRquouLWvaKat7mgnbPsU0epvXXKecctbIRw2Em3q8hYG+vF7D5YGScMbQK8h3nW3XF8UJN3+3RGqEd+KYEfaSUjq1BuhKvCxJYhhJRIBcLI50lJCDmvEO+Sfcs/2Knk9tqzb+92cR+aMxEjxrw7mOAMPvYnuIKPg8mQjZ5Wdcv4DFc4R2loMf/idaJCgWLeJYeKGK9Mu22tlLiqt5GUuv7+ZpMcWc6Hv6xIYlP9livNuB9CLWcvZOiCOYZRH5DYvkTzj4FUKBVrqyWxldeXzBUnfIk2yTzQQ6mzkNU+A/8Vc6IuJdCJTJp3ZnhqeYuanjzGr9WJLVlx6SnRl6wDxTvmEgUcOEJYgDm4lf2u1/4vz+4CWBEsjpMblmYIJ9yztICi0zbLkT6YcyPZQ6+EuJVY9GYqRiVuLBgwLxoz93Ty6I8/Dg7lWnbVOQefHGxY/sDB0ZaNhOKpnJWTYVUlORa4RHhlvwrztdkkzD/9IG9Ytt3lwg5kRvr4nMwbXCuJHV6S/vDSnedLOSxT75SI8eUEnym24wf154L0hxc/nJoKF2Ye7+WL2e3O8AE+HV9MvNd9+GH0QWnovNd6WWfmC38wX5tztQNnaPNzlczx3GqF4CUeIPNbUd37lo79u0oWGofQihRajwKoi4dAAryvY4tAWC3xFFO88oOcJg9B9w08lDlGe6D8oxcR4YdAMj0XCL/fjvnXNde2UwDWx/nDD4C0ZzaiK2E4s8OCSEG1Uw9zPF8prZqsbQZyZ24N8H4d9+II+lG3ASlx1gNtTwkZIJZnSS5L1EgRnO2gjFt49DXGj3ImYOaKI2Op2MkKTrPZZcdJE6wnCFO6NWqLYYYlaNOooBkK4lr23dccJMAxVfaTfwmEH66IITjTzwKvKvp4K7Ep1/1ytVFBSMaTDf60C7qcT94mXLW7UBhPMA9BTYd2ET3PrrRdhFZ66/Bd1H1NE4G60XdOoFatPsgllvjKd6akhJnvehHCWwZU9mwqdsh9A+nUA6pxUNTBd/QZsIS1BxMi1utzkSjOxyXECFEK+5jh8cOV5QGkv8KWgE+LlG8mCLtoyqRGJAmZOa1xfV4pZhAnau8w//+Px42Px6+iFrL0S/kmgdsQtrmZ+w/vrH1aNc2j5Rv7k1ZKeaTO7myl9Fn2+njFizSKNvh1IOfd4DerFp94dT6nyEVBSfRQsyQkqk+L4rKz4kUn6j5a9Va8AKX6j/+OnfRehTQR/4T5o9yW7/RkfGp8wHwhs+V9tfpQTXn+wdsPbz5tBd0ksfD9cu2x3rQoKzqLYwHIhWHjQwwXzEKoPm04uFHYm6yyyCpQQNMKaWqf5CeDZOsJWHXnqa1ROvQXRXUd9ssCYbtAV3X3Pf70XCNEW99zivArxcd82Xqo4TICp4TIDyXy1FdKoqMtsO816fv1MAKUlvBAIuhPhSlLX628CBmrfxUEQQuNQB+HWmnVxAQAfZGUaER7y3KZoLQ0Me6p1TvX4Rj1YJ+uktKE1jdp5eg3MJhOwbSuP8EJb1ldtTUJQzhcYNR7n1evp1mRcbLXt5HMwBmqiaxuov8ou2zAQo92iCQaRxlHrOzoaA1VJ2ediv69omxKo8YhB59U0aOzpbgESI3M6VYesxSUncwT5oMkalwJYpMo+Hfw82IVGErb0buHmPWKfC7AW9bJSnsvVfEXrld/WXI6y6eeq075zxE/bddfkSuzxS9Vz94SymcjDCToIWjfuNHFx7sx9hZ3VVg0HFa5WTBc2ilwXPam5YoJ0t/plOo9a/VVCZxLLRi2HbhhmG6wVdNZMXmS6qEqFJ5kH96cAVKv3RRTtBHWJ6nLZMojJtw7jxD+68uA1hzjTrkSEv/jkkjZBrJHuvDJSpzMX8mSXwV+8fOtsOdue1GKrLCAJ3/80Pfu9L9W/w4G31kYhLYtyL37QjS+AXBcj5wBBqoAbBemuQXAiBsbZqTbdWA0ZD+4MBotgIEZIe0F3BWpZr5ibk3AdzVAlOe8elWH1L425aYaeW95l4S7cJ6tVKh5OaFnO7ZcDxTuZfX6t7twvvHmvrWb67dq9/jtv9/jYLRyq/MK7nd4br5ot2GYtvYA7zjvfjtmLxsSet3UtoujuSrNHr2nVF8yj3c8FnLJlOtF+kmc8JMPFeWSytI7AHcZEY7xBaNm/26DP9sNDjv1ugw7tHv/+TomkGH27dr/vPdeZMsXcis/YvVDefI3vx6aeYbZfL1ulChlWpEwNEpyua1KnzPHXh8MpQykSTabBdlaRSzsS78iLT26DV6vPyKcfxm4yncPEGDdvffomeFJyuxLH7qbQT1txEsIxgMz/y8akM25wTn0x2SWvWVYXzyo0M/nrgP7YNVGSNfu8L9XCAtytcgqxVTZGyhrk/qVYgqQvf4Gm77SkELbC0qaGAIJ2mxatezcI/F4lQjNGdJ/ENpoZRfPU8EqZL0debTMrytfLFKnYH4k+8M6euwF0QbhbkJHL1Z+tGLmsWO050aU/nHNTJ6vkoG8Z9joySoRKH2waqHM9OCDAAg/fQkW/5sxjdAP6283uZq3Y/LqZ1Wu+PRf38p/XoPX+33ZC/nPr3Mh+1h+7mH5uZlbiXOl4Ev6foH1Ot95A7JS5PPLh41T7tCWJgK2+3zeAPfbG3whfQET63aDBf7iG09HGwtnnOwNbox61Gv2myjlLyGo/wJQOvCsSn4ODrOLWN9yrIGJvNf3sFD/XNsD823twHx7zYGpcamtY/FsOl2drYpMlBa3qSidmSO0yKrX8ue/PEN/2DPk9ed6C/qyZ+iPr3OG/BkChgHzk2fITC44RF/OsZTt7WZYQpcbXPklqHuGYBB7WmKvhneDKFm7j5zHXoRFDYYj+OULdaqHbsfpTZF0XbtN/5z459Y/7d4mJG7bIXC6PdDXoC0+WDYJgOah/N2n81pIOuUp7OkqQalH3dHCUXe0+D9O0IuinaAXxVck6HnOTp2Ppa9B4csWDTQoap8Tn2U0tC6F2EgYkUwqxvw/2ITQG9zMisFbhwUsvF6Ac/5jH9UCbULej97QRu4zdSXMgGEmJekPyx9YoDXR7f4HG2pWLR/nE7ShTYzVQSMrtkCjtkahFx1eKNUXA43I08/NVqcLQbiCS74DLoWvAfpvOQ6lhT6rU6pWCIZjgbHcBYw3ZWjaMTNc2vnuZGLWyCbhYex59VqUyyWdmfVVzx/cSCzUkk1EMCd9HYkQv6D1boOpqPvpvcd4OmKzV3R6OS0sVyqbzZLPqgK82RI+HnjwkRfuzfg98XGHrPjvIgR+l6j+jRF9sBMsQinkqrBa78+0LkfnaeBIpqjVmLoa2XL5IKvoE07nEcLLbUAexJTSppfVCp5paOpbvaHvl0Um5iU/ey14JujpJRHa8L49u3dKhek/0Q/j+w86gVCIFr18w7O8yNnp6yKrFsm8SLi1yGy0V7KX5fK1yERoMMTscHv0LBfJ1YoXKestM7GQyCVelkv54KsofjrIO1Y+GkBHEiRfLcdaNnAD8thifqzkZ7AtyZbxw4hoPS5cXmn3+S8zsXj09yor3pSkFbZqKGdkhPHQLiKkPooudb9AG/llxrOzKmH1IdhSpF2C2LJRbbcdjWMhl5eL6rccpjpSF6CK8GcFe6kwRloGGvC8SASqD2vJ6TLj9NEnQTnLire8aNsOGsfR7WiPgAAQdiS6HXXpVihqttqIn3JaNuPe1Gx9om16Kls6XVULBbkMRxFuC3AE8eehzNfu3G97W//zkl9kvBlYsNmaLlkPWQcRdK6vLYvVq7ZoEYRqQsGd5D2pV8CHohhekFQ4phPbQBdt0L8NhEYGhEbRKOrSFEze/ipzJkEZgL72xCvTaVoLhg5YUp8QUUvXvnlI3wXFpWymzkl0O0IQ5RQHx8cl7xPCRrTrH6YBONiF1JR2JcRDELPmUW3BKGnvDN7k29+s/3O0/va2MZdVdMZ6bX0MuhtAB9Jnt+SowEiY3RpMRoO0j1DX5LNGXNN5EfDANCAmt//zNnTVW4iz4tvbOIqUfufiC5HwBgpu4c08lkSAopp5dKIIW4ewiZ/B0E7c3L08LRaL9T79d6pxDXmFnmTVQtl7NkhC7+XcFpnTjj2s2Xi0mq/V0KMrmuNaZJXdeN9RSPSNfG4MktQf1YBR1Iax++pWI1gW4QGrPwrUGRe6fqNvIHhdrTtzvW6N02ZYZPWrn3WXRfsryREa9gkpnXl6uW3N5KKz7Gz7Zrvrnyqt75r56da7/3/KBIInpG0O174ftinv/RA3fj9sbfN+iE0iX7zZP7wx8nnSfltojwPwqLaU8E/mY16eHZ88T5DzU9Dwgfai7Ehw7iw4nXcqKnqdlwWVCVpbVfnuWdHOvORgJnT08uX7B0evH71/8urR4w6Ez++UvJPNZp1MNaWViTqihAom6kHP+S8LLrb/r9xrN8IFr79RvvJtaQ7O1kO4pV5FMz5dIMPSueYajmM6iqKu6LL/rovvf9o99v+ya+m8MNqMlwUZR5RFeDyOsghHy2iCx9HR8whHL59HE3xeTGSWn2DSXkc4kslvIhz9pv8+jnD0Gpp4vWIyv5T/vllRWYbO5PdiJcvxXJbMhCk7yy5VcfXxZkUr9fUbnTHz/Wax4vrzMc/Vx+tMrLj8VA1BI9AA1IVKUByKRhOYwHgc/awHKydwpP/+rP8/gkng6CTC0YsIR8fQ9s+ZnMpj+kGWzmR7R0sO33IYP8N0f14VMn11KlugS9nGVMhWynPZDp2allYZv1Stcf35XB441Whe+M1S1e6lanhVCdW2oBCiAHoo1deL8twkHtOp+rQTfgATk90/eCg/1aRUTIzOwwXPoeEjxsrOcXmWs1xW7ePxXdyXBZ/fnt2+hHE+f96Z4Y7+tN+PHj16hDsuRdZZpGdnHQlU8iOtqvC78zn89fnzZ6h1NdjgzlV/E8mBy1+d7zLxnUmRJXoRhv+GEY7+I8JRN8LRLTmGCEf/+Wl2T/5Z7fcP+upjfyCX8EUmtzKFLr7B33zT733zzTcRVt//ATWzQ5XRlxW/edSPJjj6NsLR29ed47Io5J5fbZqxHMjzTCx686IseQKfGQTHkZcn7YnytcJBkaMu/vf4f/cm/+s/eyOgLGrEzECR0UA6jwbpnc0EnxbkaoPP2rkLY9r7k/KS9Cckkh8RlkknjJLBhEQnEnxkwpuLkuxPSPTmQpd4TC/IwYREj+mFSniesUtyOCGR/NCtiAXl5I5sR35Fknq62iD8wfHw3lb03eHLYsWzoooQvqhx+97/W4oJXJBSIJNmdMkpRAdQ/T1m12APp1Sokg8lbR86TJEUslbz1kKFeuOjLemJkTCroWGK0pZ9aaNqRfmsvKD8YVZRHxze3z6V8Cvh5bQYC7Brdj60DAuzVy2LXCSy4LivysjifOJK5vNEXuWEEG4SL4thHef77nleVTk77ajxK6+MBr3TadF3Xdr9Lup9Byr348H9yaY2bSQhXGnAnxUAgVoVPfosgXBock4YNRkloy79zYWtIC688o/phUmf0wuXLoHSZJxJAK1pwEclQKjis18UHo3/0GenYz4UhLJpOaNvXz21dmGJUE4cbPRFkiXUrPgwQghcdYLoBw338t6sZHToklTjK5IrDX1ckJV14heRCOEpqcB5WTEar3AUTdLxyvIsCoTNj6I7QBO8j/CSTMcD2OTpuD/pCZ6fJQgc7et9ndHGFJZo40SrjFwpphPdWNtV8FIRx3r4cZxwUvZUeyiOtYSjdD6bAAw19CghyMY37VcRpLZKpgxWBTDzbX62LPJpLozglJ0+LvnJ3Ih3lTCeeVrmxB7sGziEBJvorRJ5YEzaXv6pw5igwyLb0Z83I+KJIG8NvkrX9Fxia9d2/R/7hPS/SoflbKuyg5K9yRHdwLPmJkH40U5waXXvZf2WGut9AzPvZ/l8TnllwOa9hqnjnCsFZr+Usjy8OUTptiJ81arDYfqyg6v1/VUWHtp8w7PpxweX16ibCFXqMWvqnCxYgqxjhzh2/shdlPo4npasKgv30bvIOAt/JZHuxAXrsY8c7nxYiQ6nU5qf01kn6v78+uRFTzHf8vllQlE36nVeU9pZCLGs0tu3M3a6KjLey8vbs3Ja3RbVbbm3lbidLfPb0/LsrGSKB3v7hVyGW9ZlAfBkv9n7Rtml31rycpmdKsGjfMTOJDqbM0n8KMrHCKHcGt1E1+bG26OBsgVQqHX/aiGXfqEHWnZ6XDYcJBpFlADmanCp4XAw9NQmTN7QCs312Yhjipyurz4vwRHrzXM2SyjSxq2Ju8I1eBopOmuJt/swY+AwP2ezTtZRLXaq1XJZcvCvrN0kfwcOnb/rlPMOGHV/F3WTRBCKtKN845YfdaPveh0ACuXoQzdVGSc/HVF2ngq1xFWnWk0XnaxSmi5VL9JybGHNLPUcfRmzSevJP+FioyHTJgnvwZWf9oeYMLQJZUZB9hatGczIeDKkxoz6ZEk5wKwvvQStNy9kivFUpFyfWo8e4Z3ZEqk8EQ4OwUT9U6Edg9m54VsDfGuAcIlwBvj9a4k55Wio+CpJpt3XqqGUo0avKtZewlGatIzplIqESwS9lg518kav2PYKpqYaMdMxx/x4Y5rjYaLvAl+PjfkE/Mlg+OJ0WvIZGsraDsVreWxsuz+ULpZZ3lpSTWeYG2+W+sXn2KUoRKb0Uiza48PUxkLA0xllIhcabAIlgtblpD0djUNBg+3GQ7d6uaBnm5pAM1ytGlVEW5oRqhn1iL+uKxMpvSlYY/MggnNvscFvdjz4u597ayNCLzofjTdysaDMXLk1R+USNLdkyVpyui01WpLrfYgvQhuebscZWpY1SJeV7fRXNs7+TYzebzi0NwvAHevDe1UkXrZlndcXgu5ezv+SET8qqra31YxYZdsR12GA7t7pLxtxcIBc1SbztbHPo8a6rddtvt/BTTBP0BfBp8MyvG1pbbzlTWhrMDx/CKG0MZwbDX/HqWsbvj/bLxp+rcHG8PWt9bFo7JQ7iG58cAiBWHAchFeF878F4cmaY2lI1mg38hBlf3whruw5tulpLYOn2+5MdNWq3QmDea2UTpYgJmzXfmoopgitmBJeVWDxtKk/GbO8WpZVKIajoentTdyWN6vIvXkJ/MTkv2bWEg4TgdsmeYM53mRSahYIHym26NMCv7hOYfc9964nRfloI1wv9AYkv4J50Fkju/Ln7qWXH/4KihllSBYEUfeJjJPmrMww/U4M4quXqb7hgmesknRXG5vaDm1E9zRTBH4ltSa16rtpKqH2+vEXybTQskKjrTlpsn1ZG13gt6x3wbNl0shBKE2oWQoHyvYNulnzzWZrGFqbzplPOwzdZtP6TuufoO9sFNvcAAO4CWu2nKrECy/gKbyZF/CZm0ECxh2NeQSjqCtvvxeJQIan+RLCMzz0k44M+1rTkk8ZRBJ6mS+pceqQyitUSMpRkv/LfGmchVF5p0b18TTOuIV0swYGFpurhf5Lz+umDcPw1reOphPvHNlX1B+a4ZNxOg+iLST2TTypSWuOnVznWKttvCk/UhYh/FdBImWcHuHnN3mg2Kny+ykRqGM6J3OafJEbdPBuUSS/0+S4QNjzfK78W1xPVxjFE3M+VBNmVcr5vKKiqeQBIcg3bfdkRcVJrZK5zXVjwGPo5ZWKXE7RqDkruklrsQpOqXg95WVRvCyrPHzHwttT8zlU4Ve0EqXmFqDR2Jtgr4ICv+Nm2h+TVE0v1G6FvDdls39rXbK1Z30PBr28KRNwdUTHg0ldkVYXOGLTRc0A3rBjtvcV2BtZraIw8mP0TdSlEOjGSkqcuajp3UWOHHo8n20tjsGHjOZOTSIUSOe2N95gCFVUPMnldC4bc/s3C6GXfqGaHoKabFWvI6+HZiqhjTGGk2hVzT2l4kG5Ak7bwyKnTLyiU3B7CCrFc9H1h7XMTunv6tSAnZMol438P3S+Zsios2TsMeqQxW6VErb4rbIFurasWN2ngZZd7HkdxHHw0/ZXNz7eG2z01fmkqEXCfebZ8zxRwrG3BX5ckKtpkVVVGsGfF9kZjXDOGOVPxFmRRurzzfNnEeY0m5WsuEwj+XXCissIi+yDCtMZiewDcHmiDf5ckKvoPz9EafQgm36sltmURjj6TxGl0ZvsA6gy3JtHaXRMCyog69NAln5UTbMljfAxLVzmo2rqcp7RuUijI87LC/kZ4Vf56cKkwHeE3y7177fLCB+XF0z/lJ8Rfk7ZKo20L2j5I8JqQ9JI/X1WTj9G+LecpdHJ62iDHxTk6iiNBhF+kEb7EX6YRgcRPk6jwwg/SqM7EX6cRncj/FMa3YvwkzS6H+GnafR9hH9Oo/8V4V/SqBvh52l0K8Iv0qgX4ZM0uh3h6P+O0gg0QD5934/S6MXqDLreDD/Qno7u/bYg+odPWSiSs1qvm3js3l4yuBtrmd7ZMuPUvJPm9gT7GXWx/F3gX7eqP3zF6DDLjFd1/cgaDx6KgNdUSfLC4aazCFTJzrKPVBv4NOwthxTwAYGfFOt18qQgdf3ERVYZ3s0WA0OI3xJWUu62mpXAB/lYTEjTmeLuTmSlsErOzsuPLXYqGe/wYcIJRWMx0cvN8UpZHPkNFOXpo4aTFn05WGFZYuRjQEaPgl8JRalJKMpTZVZV62Fn4+FvWbwtraHBWpSnP/FytfyStk9lhfbUre0/YoHS4k16eMRmWzMkMXkDy/tMCP6mlHnPs+VWmejj4gtjsugT3w5dbwulGaFskvx6Aaawjf1QD029o4mjbWa6zXKNhmr8DzhLvWw2e3ROmXiWV4IyysH2s+EJo2RHbPYwY1NabDNw2t4U9pafaglQe59hp5LKkm8rlG1IIILcxlwVlfq8XFW0Xj3AjU6pOFZKQuaWTowIUzUcuTYiz5YjZ7lQBSje6+O9PsKibQT/svN/0O+S03Plb182XOOshZkJwlRr92ivR4PaHVm9VBXorFWx0LhXs6VUBJw9EjQbx3vB78bV/dQgOO2dWPynUdHwTHWMqZbqkQ6CH+XKthOUXypTz2DiFI20SIupCOSNnk5WYtcQS5Nd87VbziDIWHslk9usUyfma5VaVlH+014BzIMbd1n7aik6xXuxVZhttYL+GtVaBOWqhyoaQdsYXH7TF/Hr/EORs9Mts3UF6lYPEhtpI0IcWW7D9NSmL8chk9vtKL38bfWOKnlzhWibi0LpFcTMudCwQUUbAWt4t4vYmE9UxBqD89U6L2jGm4OGmKL++g6RuWHhZ+Ln1a7IbLmkbFbfNXW5enmNq9VrvlHP77pZD5RZmxXVQ+Rng+ZvW6/X7bTEkN2vcCUQpnUMsKJc/D/svQ132zaWN/5VJG5XIf5GFLu7z+4ONRytm7htpmmSsZ3pTDV6cmgJsjihARaE4riWvvv/4OKFAAjKcpvOPHvO7nZikcTLxdvFxcW9v6vM2yMEuZ9T2tnZ1efTquopgHah76nH1MLS4+WvBOmGHuhmd1cK6sjSMQarBszy1lxEuOunnqUlD26a53bquuwG8/YyRCraw+4iAOZNN4OqROOUd4oHjWbfDrZQHztVdDNpwwf9PrrbP2c3ffzooQ1fZ+0I0+qr2bB+iSSh97jEmPb44oQZftIjv3Q4bCtzphDQorf+kIB4y2xQwB65MqU5PbyS1xcRGdx04SdgCr+mKaaMnrZcgO7+sriOnyrzx7UlTS6en798e+k6RQaxwATCPEqIuKt6hk6pMx85dEkjC3Qmjszo7hHGLDvoJQxhXqMUrosluz1nrIfDhKlCn7ZrIh4qorHfO1m/ZU1PpjVrwnVQMdrDnOATtFQBAPqV6M5rvrp7btR6fUe3eOrODuoluyyuDy5Sp+2ekmRVHVnGXKzBVYXDFKtyod1wnJw4bHmxXEILupzTZAHcox6p4oGc2nwwzLwumlhOZ6BMAeYc3ymiIQJWTWSvhckfUTopYrq5vDxJ0p24kRwOUI3K2GlgnDoHvMiUDAVut0liRckpz3OacQtAEBwdOhPJ3enVx2CIDQv6vqh7pGBAiS1q8G9roxDiiG2mjRFZCnKTcjQBsP2UgU0vZmpXbwGBO/1i+WFfj7ppYjPHCcXYr9vw00Xk02uHM+9Zk/2UXHtBIfsp8dNFKGn6KNGz2SNib+4OGZiHJSgKMI+u5r4O6Xzv4Qb7+iOSJtIaI/Oc3hac9G0V/UoBrcUHuTUlKDz2qk3qW3FTma0zcjFrLw2tWl0j5arMl9+/svtusio+kMtSyK22MzmCTXpPTV28gs5lnH8VYC+8Br13d+Et171gdXaMr5gQ7CY7xhVZiewYc7gLOsa35VKss2O8JurFbtc9XUDcqTjTkZ+6B4sggz5ZwFsh+Z2fQ2NMfC/pJvGdYWiAAY30qES70SjV8EKkkQdK/TOVXJWMbxpdpFG1QpLwpU58S64+lCKSIfohFeENQGdW7pm/YSOSy7Pv3746vTwDsKMebZOsoCMXB+omCGWW53Cihkj4r9+8OAuL0eeXw0t6/ub7789exwtzmnJYYWevznoKkzvnXkHRKCxbcXE0IgMTbo+tBnKJaoJCOh8QQd1SzLr9mhfXkaJuasbFSyrYC7aIleVyEcbVICs7uJDDpQThjjhaLFnd2522bJsqBnriA56Qvm0tWQNUY1dw/Uio+I7cRQ0GPpC7iXVgEY4zS6q/Kq+HVUm4sftK3tHSvFwmEx917N1RggDxSTnWj1ec3TxfF/y5bBtcdL6kInXhn75E+OQ/EML/BmvFxBwdjb6q5Ax6c0vbyyZV8lfVTMyRlUt+lo/bbZf3flOxq6KC1l8W/JrEj9KJuvOSK1VM1e8sMeOi3pIsuWLLO/0wlr/jqmptQhLZIHxDkE5GCyHUm9P0ywGIOA7+8zfVdpt+U+V95jNXRUMShKbfVNGpBK304bzoVP7NUpFT/JMs/Sen9ODoWiQI4Z8qX+5RRcvzs8KC+6myMDjjxbrgpyI9RlPnbZY8S46c54680qhO6LBpdP9NFYlpeU3Eu4bw0+v4Vq77mxYfy+tCMD7emMSdbREi+ofSkTIP8pUFybIQxdPkKCq7dkrpKK6iRXULes5u6o0gy/C4YssL03R4jXHW+4FcndLypmdKtk6quXFS1X3vsj3IH2x5NeHg+kkX5DW77e98J529k3bejSm7ncZfpyhT0d8KQZCSdW46ERFMM58z9qF0BRQrnRxHOlemjfXq8yptFwCk6gBFNZH8cpyDfDHoA4KOkjw5ioIiAJpCrwWLvRMJ0TvE+H1hRvctJ6vyU258DcG0GyxlzuhSmVBJEVUb4oXre1l+TLBpAzLbyDAX7YGY4sTWBdZVCEWqT5IJ+C62foSz5AcQ0wAw6GeN9nPTJHMN/m19AdnREYpXzGdsfpScBrXfx6p/mhzJ1D4EyFHyNJlccVJ82Ck/w3tF0qXtoyy5Dd6c0WWCv2c/u2naPiXy6xv3G/OyDliQVvQWs5toe4wP5K5JSxQN9hvpFBCxOwNdzsgc7Vzs/8dMkVZBsBfs5UXZaDa27wowkjBcvlyFWD6ly4uObGROqGuu/ZrkjiUycZQ8G4+fJUc0zglevPke5IQDeIHJ8roQ5UetJn3x5vuD2KRd71KE6Chau0qJYAi6/FL7OvvpptG3WUQd5s2+3uK9EZ9G3nWKNn20ZxPRwn+UVAOIEKnKZ3mBebv2dFWhaV6xYkk4nFQeiS5xmBmTptxN2xNSxE90CL4BOCwhrMUX/EOVv3BsWX9sbVmHQ1+wbCH2gGd914/vdFDc6CVb5ALT8fuSlmBFvC8AhUzjGfOuNRwRTIBXVYpcSdc6ImrKbQItQ0duHQLkzMicMmVY3Hjtv8QWHaOqKHKlyd85ObQFYXNeQF2jq6RmNeDDJ5jEDLlaaMvPWuu6aNYKb8PWe4CxnhGn90/wKoSq7JnjnXS/HMbDo1IhXR5Io0r8WeqVfXpgrTLp4ywa+2A30b1c2lNvXQSgmVQ73Hm1d29H9qDBR6ro4GAeVEsvOKYp9lGYmCaThcIcyxMqYHgSQXhkY57dy+IyjZS5JAvG5XmtyfSHc4ILft1ksx+q+U7+v9w6mgrhP7Z+VJfnp68vXl6+fPP6/csXCcJfVPnM+EFlnwTeNOTr0AfKvxVwyAJ43/RMIEDwesvZTdloB1cnlWK7cs1P4td8yu6ZRoxKsboMntHrp+2mOE8QGq/KShAei+BOg6sPnHi5E5TnOdnF5UdbhL77IyrM+w4vSd1ksz/KnQn/mczxzaYSpZznc/zXQ7zPwq1CR7uGYSG4ornwfUeK5fKS/aA8xFwCr7SYBGhFl6QRxVVZla4hejTY2jGaGGjDVUmXTsaX9JITdTfTasV4F5j5OdtUy4EFzhFtCeDnqBXgLqjyDmtiq6pDb/QMOjDJvXRyaYQFSdnRXDjvKcdNpotZydV1y/iHC1XDz4Q3223a8yWfzVFfLoUG01Uw7m209UuSJznM8+EJdmOXoHsIZivwcZ4/fUpHI5JytJuI6Fwl49s1oRfg0JgyNVH9EBWxke5wR0cV6sipdrqAaZYtIxVo4kmzfMozOoX93NVQp0Jz3PhsI9jKPqyRifHwWDPgvRk8Q0yTTfuqenEU/qIREpINVXvesoUXe/7m+7cvX529GI3Mr+02lTOAXufw73Z7v0MzMs+Fwj8gi/z+tK6rUm0N52SVXVH8+vpHRkn2Vzecqlg4TOTPcpSgALqw7BcEme8LWlwT/rbaXJe0SRDmix4W4ljROE7WPzPaetOCMbQ86l8yVaC9Dif7WBwZ3ygqcrprscmBoNzEp0BjTj4SDq71EQfUUC7ru0ZWhcuBVQR+DZdPXbFO5erwQUdI/OU1RQqJ1ndNxI+eCU5Qtuz6wDHaq67PZq47TAowyfcNFZMgVpwZkn22DDMOwJzMnkFTgvxoi926G1k3ZgizXQyCHzIM9AQZKBoGK7ahS8Xs4XNyRGz8td75a4Qdea6KxoI7cIAVOzrk3KC6dBjZwt5R3UNkqZsgIPMgOeJHidcyEVifhVOVm6kjW1/2tb515b+rSHNB1HZ/QURPR4DKag84m849iS9s4VQkxdeUoO029d4WSzBNpvoHMiufUVX16XJJlmm4JryvHnWdtXNaVWEjAhOvFWc3adAtpiOLxWc6vK9ZI5TGTXeZfAnVdd7apMpQbLwmxfKBY78dqUsW2PYF3Do+TmoqK3J7TR89I2bik68pdU0iOeqYdBfLZcfyUCtnfPrD0Wjhq/y+6V5DSRG5p4426xL8eju5+ydVB1OkLWuPkbvotsvgf3hOIHvBZdou3rNzAhNyzwfylFUuEG4W+X3z8TpL1kLU2bNnt7e349t/GzN+/ezL4+PjZ83H6wR/WoObdTfJye9+97tn8DXBn6qSfuhPJL8m+FO8nL98/0om+69ntLgh2hf7001Fm1664OuzZIc3i/zZv0qh6F+fXeNqkSfv6bXs/KfqZYIX6p02UjKvW/mnXhh+7eMjisi+Bf4nPkIFQ1MogcnjeMoADVphkm8kXzcIjKy9CadtlMrVoie+6fBEHvj0VXrXKU0ETmkakHO9VySD+UIcWc6Grl4XXN81NrA0tJjGCV0STvhXEMf75dIKaQrrQVFzrhPBx6VsTz/SlE3rcx+59ZHtdig8CSAof2KA5seELoq62VQg2Gr4dCHGZxApmSwzRxQJWwDyixiXy/ZEsN2mapO6WaSdHor3DxYo3kEgosjiMUWwY9V1dWcWNsJ0YmhVtxKZedTXE+wmM1SR28HV4fTIXrRQ7haZtkOd3F+h8Yaf1wtFrVBGtQ2ezU1s66CKdqcH+NH9jY8NX2ufGvkYIGhcEXkicGay/5n4lyB6H14+JM7FZv6yEEWu9YwalheCLMam8LLLgX26HvYHGYhp3Ajj9UXaLGZijgnKesw0QnCrB/1pgnJc95luOX2eTEEhnnsH+YWucuRgD7PRKPDj6p599vjaydyhu50PJlORhXD0LZEdPVHWT+3dIJn2GOkQlBGFCt0R4p9crsnARE42YSEGy1KppsB4clDQO6OPap44/keuSJUkONC4tZ58D/n9BbFgH+VWSg6zncYcWDlH9yLnR0mWHKnQwSxvFnLfZNOOZTRTWuyYzTVYGkSNsbvD32/NDThDmts1ixmdT/g0ZhjNsZBkhFbXVDXDUhOzyia/zLUjMokPd+0gD/tlyNHgo+d0/KJo1s+Lhky164QLHaJM02Wql2A1WVAxTUrzM8mSBAbHce/okh13u6DRqlUOx1IwCxxBgob1QpzcLVKBk1p/ThCO0dfrB9l6kAfrqYKzcp+mRlVa6fN0gnCEO3S2mn2KnNUipQabMczTl1pvdx8XefLfCZjiPWdLAuZ4rUx7t7CSFfHT5Hn+cdFVM3wNehIh+dQdFWsiysUAEAEHieRWNqJhSRfVZkkGpBRrwgfJV5zdNoRbC4Lme7bcVCQZSEb3mrG6+6Wkgzu24YOi1U6Onyid4/UC3/Qfpx+Mis8ATwjMrnI+UdZA9SLlUibhrohjT9+tVFMizIwjg1zf+WLhCvKyDJlCnizgcxX7vOcA7oiCnu68j7e67VOyiqkaAuke4ojqBYfqSe1VQ9EkIvf0UMWx6/thCANvy126XCB8tX8kMTPA8NGxLLunEopL6ISzSgPEm7FmuHSM03PmnxDyPHdF7CkfF0IUi7V6k97fsCXJElYTmuxQxiOOlbhLjNFUpG7NLcJ+Iecdk/OOOfMON/nxpPl9YQ6WjTlYbnptc41uZeMJAsWsmXtt9mSsjRVfyz0TUvLAN/wB+3wDj6m6fWqOBjpL6O0TkZDjh4lWC5MGRR6CwOB7e0UTuzNqDfHy/camAnVsfOOiqNlJu9W56Q+qr8cH7MDWOYl/SetikmJgwtwpJi5pHlA7QpYL3C7y2H3WjxA8S/47fv++ubu5YtX79zGwuOQ9XF/YNMkR2eH3i/x2kSbhLpkg/Fx9iUAoJQh/WuT3O3y2yMNCnfg3F4LVNVkmk/1Uz2QtX706ff7d+1cvLy7PXrw/+/PZ68uLBM1Ho/RaVqRury9izirD4fViNLpehJ4T8lR1uYgcQz4tZgqnZq6uXhyFrY11p1n9TKU5yfOc+uHp0yKns+M5Gsu2D/Mcel/HvpgW8HbMNzQtxuuCLiutbcAcZfaNC67HkRMGhJrbN1zmx5Py92086uExhNw/W8wnpeF3xSQtcjYrPyMtu91uhz/8CuHBcMoxhTvSXMrFox6e+Pdql3K03bKxA7C1f/+P4XSBfBabZ5BuNHL/tEWNRsPgzTiYzo1g9cubG7IsCwHCtp7bGpAw/4XZO/n6Ek4OTRjuFBqBWU6WfHiMcD+eY+guaa4RY4vtuHPHcMi1HVTIcggIOSSz94v5dvtXMS6bl1QbSchpkqLRaHixkDwvCu/G8PAEgdW8FnY+LWDBbrep/g386vT1N+9enZ6DxP316auLswQp9lHkZFbOcZMXo1Fh3dMnxXabqk+5lGeVDAFkTGElcbk7u2tKtuI4z3NTBiqUWvpejny2wXpNZWynqTVLu8qHJ3iRH08WrdyyUMb8xWwxN4sxz3OG7qt8eKxt8avttr+KXbPdQpemAl8uwBaya6dlIT1ieHg6DHRsPz1kcMns+WKur1ztXhvJricfwTMFwKf7mqmhw2XORiMyY6qo8rFFtdLi8ETLhqUrG5artJw1bh9TdF/kw2Mp+9XAbxt8gnSPF1M5wKVlvF6N0MvzVsXxAGmwfbMFwueL/L4uaDY8xnVBwYNQ/5al6J+ELvWvBQAg6gfweFY/ldez+r2p9Y8lu1UFl3Sxtj/aOuSTrUU+mHrkb6cm+Vi2JbGNys5J09gfqlLORCFI+8vWpR5NZepJ16Ye2uqa27Im9odpIzzYVsKTqhJ+mpaKQr7b4Zetbc23xc0N4d+QRmw4eQ72qAnCb8MEykw+Qfj0gXt7ovwjZnN9Sf6RcF4uSZPfR/HYrzZltVRVRMQOSYP6mGqFOQPk/aadu1Se58F3JU2g+xMEFwH3hLpWtfBddWU0gUcrUumpSuh/m9H2/C60LuT1rzppmrMShLtZlddwztTQqnDQrKDv5Slzz/6+bwNKh+ddUc/3YpLbiPZSf75pBLvREJZouzW+A2ogTDpFlAlZ4MWYBHWz0TIr45CFCh94RQZXoOi5Ioti0xA9uOM/XgzKBpTRUOxyUNDlgLLBAkhRL/lgXTSDK0LooKnJAryKx08QPgk98h+3vwL52mjHGDKlysAIoM6dPsJhTzgdYUZ4eIILT8DKh8e7iW8QLtOnqGPxK1m4VwGyO5AfwlN2r+6Zb0+///7s/P2rN6cvzs4HC3ZTV0SQpQpP1OlcyYmUvSn+yMpl6lG6QyAVFHmP9o8itENj5frl7pLxsRcPj71wmmEp1UO9KspKDa9P486Dqi1SZJkKk+L6m41oyiXR8lFoTl3m3Kwxl++kxKuFoHso65tNwZdk6RZClelCu2LhuFx4NLXfViv4uOvABrorrBctwhCq+KkNRE3QH56e2N3xzSKfJUUlEoUBylmV4OSGiCLBSbMuVyKZ4xeL/L6oRCy8ORkXlfiO3O2wzh1PtBC8glSy5HgS+QWSQK3xNPBJJtrhv++zWWrr7fDKX8b/jA+Zwlg/M3Z9HeuafYzDOb11yqHy0CnUSD0vqgp8E9h4talktxlFZYfH+NZync/757NrVuNAP6cEs/FSzy1JHC6NNY9Hc2evpZ3I9jpuumQWXB6v5egpxnjsHO232+QDuZPyRTLMcz4aycdNDQ8d02jZd+8p4zdFVf5MviN3KR3XrE4hMnuSyLLfLHrNv0ROnWUwEX94ejIapdRIogKfIFwe5eRI0ryD3wwfDx1SJeHM10m0xBX5vV3ZhdeHOceFGc28xMVOyRPw/Wv9OnJzm+DWnc1ga0jCtV5pkOQ54A0GG/GU5omyQMqScWK9EZIlE4lc8d3+4eieDyHZMX6xmPE5UhA54ijnpjPEkfLL8SZpZ4KHhyCG7jtNTRn4gkj5Ps4lTccq8/odDsbc6yptU0OUFU1CmkWiTVDk76ImiTUrMWxhZ7nf9wvfFuLPn8cSch+TKWgpyp/DC70ebwC/cYM3fPz6zeuzzJotm7ffXn7/yr51EWleLaZiDC57Jb2+XJfNV/Kg1Thm9RdkseGluNNh0QD69DUTF8VK3S+mAicQl8TZoxyDS+u5f83za77dSnm7lhui9mQQUwXPkgqUJcmE5tdcoYETLr5iyztzTcDNsfT/4DLnkyW712yCRW76YGsfCDYwvTlYi5vKEwtKWm+ElFo2sjOu4AaCPX2KeV7iEtiABkXFe0ja3a7LiqR8mOelUWZIOi45bvLCjiVotDmh6VueUrTdtpdQKuh6m3J5wW6IWJf0Ogyq/sPp+euXr7/JTJNKeg2gRING8LKuyXLQsBsy0HdVg7TRQdSzZ8+uxwv2jF4/a/RI/sunpkGS6Ta7VUmLqrpTNgTmvLPJDZ2TjYcqvfFsTTYeqvTOMfW2I4qQnYEXl399dRadgu8+yxS8ULdIXvhGKe6mROP/pASNBS9vUmTRg5KJQaYAA5X0NW83zNFoyVMxO5lLViT/AuwXJDvlyFebtoiHw2NM5T/KvJJEzCsttAxHk+SJZL5sNKJTkQ9F9iR5op6F8g6jrUXZaER3gFCfpWrOPDw7NrQpVmQA12sDAFCEi+7ksLmRqOwJ2slxbIcR0GgzeXZxx/DrhbVrPGwodbi+PeMJMLoJws661i1Sbdk0ZCkP5sVARcsb6EiuSUvsu/M40/tqsd16L37+LFPw3blkgkuexub/+dnFm3fnz8/eS6LC7vvqs3ffucYeUDQ93IcGq2Dw7vyV6cmHJ0rSmmRGvDrIp5osBFkODNU62tOh0zAJlZ+dlnY3SR+0LWIFck5+2pRcnv8H0BGgj8aDayYGhSQMHOvuakDJS9GBZPpexXd10TSmzZd804hvxU0VPTWQ28GrReeUECmhF0lJFvHusCJgmfSV8fVBZbzjve34+aAC7LzsL+grXdAu/X6B8LcP2bwetF7iPk6CqZUaQUyxU0wFZ5ZSw8yYYs3zqxKwMTM5ew6m4aC5pNV9r3rlzODE+WvigTkzPdIDINPBMHy7QPjdP58gtcNbir7+f4AitUdZkn7+55Mk+b2l56t/Pj3uPmTp+mmRf6RpyXFypWzrEtxiHbwErAMVidl+32H7/dz57tT3p8qNUJci/NdqrLBidi0oQFtKU8lSwBw1+67SMAI/VHMnyQ9VFHQhgrSrcs93c8c88U8LP0RtJcD875s97ExuX90NS5sfKtNCUFAXFSfF8k4pqpU2ezx4uRrcsc2AErm1LRakaeT5Z8FubhgdLEtOFqL8SJpBs1msB0UzeH39cgU68NfXXzM+WHF2MygGVfHznVGQ30CNeKBsZQfPoShNhtxkSbGUB3/LV29Lsb6AyL8tmFPEEOeeXqtCMoJ1VwNShun2C2d8wejr5dIZlD/CoJx9KhshGfCF2OEvqrkOthk1aDGBO9VfkPh/WASCg7qWWBqXiQ2vcrHDPx5w52LwHPholPI8KW9qwsHxRSvA4SMbjVIGJ2E0idzSYNq5p9GYjyWjl7y8viYcbmk4xColSwWnsv+yZs/e9toWfiEKLtJyaTeycimFoQ2vVLRs3RlHyROkVu8PC4S/+wUWKJ0mMlkuxLU5J2p2Njnfa11yUIPO6PKg5sBLv3ovif/Jb/8fP0/7OSkaRj9Ho7Ve9pHD+MXnaQYEsfwsQwfs7rDBg0ptQng6Spy2/fUX3ZZG1mFskpbj5tetv3O2EaQ5Jwt2TcufyW80Y/EAyLQlw5PXS3/5f7qXQO3bQASmw9nUb9BLpH6gl3CpLf4e6Kci2k+F7adi3KzZplqeyp1avipx8au77jdjiD0dhwd+I9rv3muvh8VDPfzPXa0K4/OfOgfp/4Qe+kdPNad/eP2AkoBLlvtoJQAwamWw9IoVSzUF6kKsLSlQLiANKnoU6so/hBrZ3Q/TUj5ES0OLulkz8WhyQO+v17MVJRVBT5Kj1Ctc0aZo1zYtsU9A/HabJEiLKgp95B/VhLZHP28Dmt+sAf+I7t/8A6j/rXq+6qXdQciHUrgyldEHwFoH6TcoEQVdrBnP6WOViAvOqipVuVsep56BsZmKnIabV1PvaXY8l+xUl2DfnswBZs1r9KL276zrOk9qXt4U/C7Bq4dGsy54cdPkZLuNW1Oui6j9i5M35vERwBHlwS0d5FbQSB46lypwRmxAXB+XRKCpmB3PM4vbpCHnOthHn7G+bCbmurrZvA/e1gNx/kDuml4AVxc73SEBHYbM3Kqb1nWgRV9BSH77fVn7pokKHtdY4DxLwOrGBocjMQuWcpUmq01VgcEIZIfIRYDesi4ae8mNtltTkL0BRV5JrU/N/U4701gU/daBJufKLYDMSjA+L7zoLlmCEJsVTvSWEzTPG4XeL1MP87wBKt2q9cjdLxhtNjdkmRlIvWPMbWTmmjWA9tpkTGHOfKxj+iLgG41hGUpblruog3e1NoQweiABQWOSxDEtzo8ntL0npqbxPCczOp9c1ynHN3UqMEdo147mde2gynRVhn+jA/i/l/RjUZXLgZ08kJmtBkA68KOj5Ek2OKMLtqGCcLIcWA2aSjQ2ZV2uyUCpLAY35fUajC0LOiCfBC9AzViM/0ZN4rNPxU1dkcw8y+4WqsAmG6jz7yAfzMz3weB+oPn/EzzgWva7ZNngybNl0ayvWMGXkl2aSZcNnsip+GSww5Ey3CwD60ObDV6Y9zZ0xWCH8eD3vx+IW6UrLZpYcUQUZfUsK2V5TnHfEs5ewDenPJN/PlG/1Mry+QhB3TE7dKygBMfg1Roqq4qGpHUahpD7C70s4aFixfK5fQER6ysi2l/DPK/rX05b0fZORZpGf74txZptxMBQMmB84BJiGrMuPpJBMaDFDVkOFD2DhgjVLjJuZ4Wk1xT2y4ltywM1+CKg5krfjgt2TcSa8DgZbjs+GymxzukjZ+GM5uchxnbEY0kJBsjMhM83QnaRPUCIXLZtyL4I4OShBMiCoGpd0v6KLZv3u+LwFflLCR0P3lAi34o1GaxYVbHbkl6ri+srMtBXJ8us7UGXx+LehdlplupY58Wv7mG1JShSYf1r0I1C9T2Tv0znB5yuC0yi6VPBvNRTG8frV84CPfIggQBHGxSDpiqatSYm6XTQMJwIQUfCPvZ4qu7VpvS3JAEHCH+3TJ4cuXUeJX9LdrIFCthET4TBE1v9kzHs69qGRxsFsZWbYlA2gyc1BEN5onw+2EoQqm0owdawhKvGTUP0pjx2J87Qa+9opETIzltVQ/D+140ZFCEHbsBodQd7JRGSUtMcOb0UxQmauOtSCm72EQtHjL6pA6wzst0KIHhKRqOh+XmUPEuyIRmN9Av1J4P3R/ohSTLSFnxVu6EQXa5ufo9vijq9qgGofFqm9ztM8L35mIkdytRLY8I4pC7fScV2S31uMxpRKwBQVwAAk/cWemQh62wpva0d817Mc/cEQxBm3gvhnSuGoWn88MRKwpFjgGTmMwrHgPkwz8WMztt8+sdxS9j7ek/c8gWji0JoE4fZHLtno+e150RiPJCnZGYenupzdpvnk+4Fz0eQIBIefmU3C9mMOaZOlWd+lXVZk/QvKcLfbCLIpsNjFRnByX/h5n8ulGXoe/j7Y2riPejoVFLczN5uvOPgZR3gPtGpf8LRr/Vg71KioODUuQgL98kxhh0o/DI4l7ytUzFuCMQ5bTC1P1E7hvIkPqabmyvC36zMvBzK02X4sjtfuOxw2sqBUKewzzM+9+oZktT7iKmX1Kbd2XmVKhdzLOAPyqL94891c+oN1oR1Vw5Sk4+E30Uxc2d0Lod8Rue7R/d94GAxEKm+IShXaTsKZpaHC1IOW5E76czx2CbEDI1GQ+4f+Sexwl1XGDMl2kSYoQgXkKPKg1F1hqrsjKr3EXMvaWRUlWaB2WZ1iEa4sZ+7HydONzlNKWSXuHTW9Vyue/8N5rhBO7iycZZDONGAxA+HKS6Z1Vg6c8IoLVc6yHCrtjxAWdWW83DEMS/tdptG3ubrOg3pQwbG2kt5gMLrIKXr4EU9bggvwRdIeeFovej5nj7tBnMw42M62Ayk6V0FFqSion2qU4Gj/IHYdLso4KqziCJNgYpCVviH44O0jmG2wzWQdvHpSf/ZRubvtTceL/eOh+5ksbY6+TYAk3jEhLbZHp7PblI7nd2Xdja3tNjJ7Kb7bD32tddjrWbxbR3MMstwhd1sSLi/EB91q1DpZ3QOv3eOdHDqinj5zGrDP3lysVMwR/c8N6JjTrW0lQr4BOEM9mYd7s1KgSO+Dm413vTNHje6k4ft1XRdUhX8wzd16zMJh40PUnSBHOeMiQvFCQCSHF7+qeVl7UsT0j1FHexSzYy6tWNqPDWfJUcxGSpQrCNnISEPEUt4G83UE3bkzjM8QVmSYOYPpoiMiEI21SPCFLyNgoiVdA1PYEhYKyTzoyRNjtj476ykafLsWYKOEpRkXEeqPfVYo+sBqibMdBajdZ7NuK6TwvPOjg+0/Sh5liZHZVCp3UmHx+gIgsa7clNKg5MJHKjCMaG56L3+oWhK/UztEvxzbeIj/1kSuEOatlGCMu8bRTtkOOs0mSZH1EmZJOgoptgwW/k0+RcnAHPafoCsmq++qGFWv6lbfvF3/7hhpZqwB1q2Q9omPEsc1vC9V1IsSLTFDH32r/9+/OwaJ/+duO/+7fTZdYmTzHv55b/LhF/4755DQuzW/me3diDFLfkryDBxM3y7J8PfUlnpv375X261f0Pq5e98Wv4Dih65Rb9yi16SSE+0ad+5aWVGp8IjVeFx4p7vvnYyJMmRbIa6y1Lzut1/8ANzWhcxUWWoWfhtnQoVZlmPsEHiUibqP9f5s/87+79/e5ai6ST/l/nRs3YifeWpKZQ75M916zWp7mOTBAr6SRWUT0eyEPwn9aifvnnoInrDK7P1c3JTlFRukVETg5BT90lS+tLvDeD7FBXMbAyaO78WZTQ1rglRlof6xnGaoJ4v/5KgqVxy53U6m+P7HcraJyMvNMTh4x2Ec29TcelXaHb3u4m5te40YpogtGT3bT1tSXIOKg/leNZR0iJEkAhNZk87uENlR0SWgt+9NjJcWF1MEja61aAIfY27m/QO7ET13GwOZ8vosKVyQFUM1LTtPrvd6zARYa5niQUy6nza9y1N0AQpcotabDhR829f/WqdmVbGSrTgSG6RrTFDQ97K40eTDo91cdSBoOjrFJDEukWcIITTVj223UaVH384hvxyJ8/1KpCypBTjuiMeWbBq2L6qw0nTatm1FVBI+CSJ6PjPbmpxpzT4G14N9Mbn3Ti2vLS10LHVHiVPnNCZXlcT5Vb7sk5hJ3AW+veF4OUnIyDGFrubwmODWg1C8t6pPbHTyAwOrPN9yxjSRGTfeCebs5dppzATR6GnxKnKExtwJVKqwbEyRdKcox2ZvZKS0jx/BULRXpYYE53zVARcQe9HP9UImX1IC8l+7QZ64qAGsUjHmZ3vT7Gdr9N6FrSe5wxp6fidbDou5F+uLy8D/XGpydBmML5A2qDtNgWEzCafNXOEdfDTwgRzkJ+KWNeqNR1p2v2u5ZeWqUjWNYz3E5LsIhgGC+FpROrulMA8GLuZgdABU5/kmYH6QebHROH9dOPfqqUMrYI17hsbJwY2RN1GTVp8HymC/uHpyTQFZF+wIgJ9oPtdr2rTESx4hiQZAe+uuja+XbEdfyJmbJ6f5Ll3BintQaCU/NKRGkqEe3a2Z63LXRgoxWOIvUZ67Tg55lSdiDl+vVF85xgXJnZHamW2sFZrsGWNw+SBLahf9XBotxefhBFzmidnBntAgwSOn5jj0Q++Lb2r7PuGs02dk+1WCSg/RlJueAXReolj5/VdaHv3NnZCFMpPKZUJfqhVlMdW4P/jo8v4sVPGF48uQ6+hN7S6GxRXDas2gtgL5QbuTmGPdG1ymrFvoAVgDk8SIEUugL/uVV2rqwgzjNqUnXCjVd3w6sLoS3hOsdfnbTiGVXmdM22aW1XstnVnGB5rxHbtZKoiJad/EvFIuXVd3XWlD9dnAkojn+qCLi+cWZJ6tbiEeTQrfURdI3XF91NsQEy4incqSyowsdldBUb71p76d0gXTCuv5BBf5Me6xe0NO+wEm+1MmAqUHOAW8IOxCiNjyuBiXU0dgQwSyS4UdKDMyA7z6zp3T4+6MSf9HqU47Mn9PUi6UCK2A4TfAcR0AOl0gJuuD+vC38TaMFnKLmYMaCy6Z9RS81gVrLtYqDPd8DgsKWY56dwDHjsH2DTl+f0OgQgPWtiMBNpRFonQ3B3GoHpH96fg/QIaRiPqqzunzvSwb1VLOoPvd6tqB5Gjm3XnGEDRCecODvPuDuRXuwfgdRJcuKZUX7YeB7u9vVAxa/HtJjUhFMp8NseF/KdxDmif6pRiv1zA58IVXuTpJme4yinmsRUkyazwBu3rqUbKJHLeTpjSxZZKfFygrDC/dgi/3WizCbjrKo2GvjBll1WKcCH/+SmC0dfIdeFchO6bNZ0J4zpXun1tSVJSHd6kNNLSxhJR+PWcXhdyaYMdsq6q0ZUdygzaIVRu/Q4TQBh65E9RU44h2SHsFa91/V4Fp5vtVp1dgUEo4zK5CUPSYkzZK7IS7CPhzUv6jlepgH3VpcpVRxnytOgh0K6fZ/kFd+a9s4DbqybHqHFG53sG2O346GDjol3Hq5SjYZ6X0+8kyVkLteBYuCkWAXyzb2xlx2SFPqT4m9+0yxvc7O+akl6bxN6UzICkAxvqFdMzxbWa9v/7/xJooDIaa4n7oayWzwu+lDK22sP20SlLLT3Gd04A3fVRbYy17hF0RJi/xmddlw3WpyRYxCbHc3ZzU9BlIyctdcZYzuAWQrN977mDPEvQ9I91appdlZRwkCJ1m5uU2tX9nSczKPar1wt1K2OdbaPU/TM8QZ2l86iefpDT4Sb/S62XNd7k9tBjiGlwlTfjqtD4i3iRt15hRQVjY1KCoYxeJGRpeATMYNh76n1jscHucsML2zn8gZGo+0eC47o7EryPWZseMvuOMc6pEMJldCT62MHeKQlqB7X+qO825FlNTjtHF/icknFJ/w7BTx+QTsbvFbyOclvMCdYzj8uZt1OWeu4rNUZ6NkiaD5gND434Iue2Ez1R/JqoAhRxsDd1BspBc9YIQTwn2hkKN/0yH7Wipgue6e0qfNywGxKV6Fc66WhEVylFcD8NtnGYoum9KxRnZGU6MDTK0SarmEkZi4F8KwCbtjVCLVKCcJOXEB02RZNhM14ySibtKxPOrhmDufQElNIbbfpNV+kGGXMGNoNHqwfXm/FupxDuCbqn+b2CMiE7C8Uq6WlGI10xwAqVOhQ6Go24cvAvkQ/dqvd3dbRvAet3KceWszlOMwghDBPATqBsNt9lLur2rxmkBwemPX/gnjWJG7wBJbgzOlVepBThRV7Z0Vmo0Wlfqex1vtCjo2mqwWZRjkcN0cs2+mf/0LCeoVmMRrrW0Sht8qodmkYNTeUNjUEnZsHQgK02xxvVU5j7oxMODt1lQVd2U+xSgTd4ITmEZAZuclzn2pDTZpg4glxth7wKDmAsPH1JSqsDTl8bffhS8pop3q1s2vK5DfR9Fm63FFeY4xrXtTydHVCn2SHa2YXcbgXZvOuL7DC8PMIufH2FLc2Q/9GzoiHyvOnvF9YLQvicXxYQvAptjHX940VB5VZjZaDR6HjYLtTpWZ3+mEY2HScyqgo1Ywq4qFNuCp3aX1LG5qmAToJdSB6J3X1N7Nu0+ZTu3xXFvhEUnV1RHk1iMR4eVGumKc21ViVEyCrp9ZkCjtL6Flln6/3kooNfbwq+NC5Vyrfkb4lFKDAoG0/+lgxU9WQ5WBVVQxKExvS6r2KAhzYXsTtAVnZ2/I9aaYHCeM2hABVM09aXeDbHPFdmxJOJMvhuLeq4syrUsuwxsofjo/bb6Bifnmy3Q+7Za5lcX9SeDyCa8NxPuOuE0+/Km33nzYiEykkhuKM07eqP1SVMKhAmHW3VnrL2iokmdG6ga1FaSZm2qylrc7mGg8I36nd1xq6tNBaOrjKi6YuajTjcw1MmkcDwMupFNxqRjqO9xYJzve0ndMbnuZixubpthEdQb8QIfUAx2D0betka6OTWm0TucoXfuLgxY4nui1k5z1nPwKmQtchISSUuot0cXXqdI4RlRT1GgkKDLvi9O2XjVUmXbzXqgFJayO1Qvn3DzyFvquUqjzY3W4+Gks5MpS5Ogg4L2HeZalYxOMup+52x4ZmyTrhjNTzQsY/gXfIM/bHJCZL4cUcAF48UwMtVujHmzMQ7ugkTuEWeoSfs6OgfJ3qT0GT7L9bjypo0ubRaZA3hIWuQEFmjPUWh6b0+4GXDExweCLPZHNvzYHaMe3QD2f1ul7XlHP+acrRVRSqMW/B2u6yRPHhg0U6R6d7auD3ZOrW2L3Xje6ngY4vd4TbrV3VPe79KVloZfKL0scHe6DprwsbYceeUbye+0OrcxBjLd2efFo70aidW69m18nfJdNidL6KdL9ut9b114FvQaJS0Sg/HedlVtbV10pVnSayuhLfbuoa7X756wKjzvfJZeoT/hszwgN+GTKJ4weMcL7RrTvyKErrja85uVJjwVk9iOvRkKmbm4emX84hR46J7eWRqYCsTbRKod82IfIffiAhMdFuRPLMHDNfEY3lMlaORU6e9DnSM8o/nqsZIE5vySkq3MUuioq8+4yX55XQ2z7w+PLzp41VZCcKjm+wQnGVDo6d2MGN3sSGxDxIQsnfVu3ZjA1su4OaQ3m5I3mbH5GbXrnBc5szueqXa9dpXxgwMKip1sbKaBtmbtod3t3I00kXD7sY6uxs7aHfzfaGLQ9o+E/Nf3/ii0/jgSrUZb6gKIyeliH9Yh8zmwP6aXvZnPdqA9K5P4SOB5eQx4TVbklTbukGpLepjOy03K8+0z9Ti4QrEguGZ+TrTE14zeiXfKzeBarUHk7RVPfRHo+UtciDFH1cpxwJh/osgSNVGYHEBTcJUhRHhK6dHFu5kjR6ZICrxSqkE5X9JggFFT261m6oyJihPT7yLKXI7WErBDk4SzSqleDZHoN0TEN1QHgc36UybDEOZaI4wM1/ud3INOA+F+9CYhyRBeAMPtewxhgvc4FJTN/YY7cbpX30+JbeDSilhm1W6kRTKUwVoTPdM3fZyFjdd54zaczp2/ZBp4Ies7beWhSiM9ZaaVnlpbHwM5kShmfFqIzacXJh2NI8SHCw45APyg1+Jiyr5sDzxuSSYjSAcYP1hpD5LvUq8eUTNKoP1OP31FLTyyCOoaDN9RkoWD3lBd+kwWT4jFa4U8qhxcSTRz0nNQV7+dejgb164kJl7dLtr5UzoO0of5CT9T4ArCHnYI9r126AZeBvbtG+by5KvN8oi/SjG0mKSwWoVB6ckN7W4e0Oru8T4ffgTEEIblqs0Karb4q6Rp0kBkSO5vZF4ejLhf8hPJkY3Bngrhfzz9ARUT8wH9YXzJ+ug+SL+9CnAeSqbpxZQ7oqT4sOEP31q5dGopM7JcrMgqb/Fa8cxNWs1YpKew8qTG5SucosyH+VvLOAPwhpSx3zTj1iM3+ufyxcy3W6HTRX3O1Xa/c5mvt/twCROXcFzpHbg9YE7MAbzv3/sPuwMTa6V1e9B1a4K3OhXVdGIt4VYv6RL8imvzIFKNTtffO5T///umf+7Z/5P2zM9BJHmf8am+A/H8FGhDtINrzLHm6tfJ+Oc9xzQAgWwXoh1ZrHVHT42DV8YVD4PS3352ENuGHKDq2Bi6nxLf/H59k77KSrtVPdU+1Hv5lrn4q0FuUHsOe23mjNdiOtSdLeKwRK2WsJkcA9BUz3F3d3KjAIeyO4c7AZJliQG60SmVwoL4SBaG906sfJNW695g6UwEsg2E+KqEW7r4GKVerN2u/VuV5V2ifZduIIS3DyMRq3XiMlnb2ZVvbWpsm5rq72KjHzhyyTQaoOQaM2qu+BoAVj40RFF5Sod3tYKXxDwESMAicqvB1P5L9Ak15ImSL5SxIOYQ5WYIxPJHyYVvNQupU64h3AosJur81WXYkf8JtAa6kl4q6AufIFsNHpbp3LwZUN4Dg0C/MoOxJEPXegCZfCZmLvATTs0Gg3TodnChzmgd8qfaDRq32+3NwpTWD5gm8RpyJVzJZIwYM/edboKsUnATF670MFvfc0jBSYHXXPl+smpK9FWccdHo091ysP5MxPzPEQYn5I+LJDkiOxQpv5gbaagFER5npNpu1coJKL2jvuw63Y2K+e5LIpOeWZKaG/YhQsAuNMVwxUhLrF2jH6/VxRuIziUzal2WjRCsLmTe8E2VxV5wYQViBfGwoRiOSaOMerVKqWz43kEPUAKD1HMgBvw33egAxLjU07h1jvW7ftmhp0YO2V3MxrxYZ4/r1Maoepep5XnCIgHKtjgSpktSQF8oFuaRD0eBfOvQHxxoO3Q0ejEoG6YnrNmfACw7H2aHc/1hvl81TFEiHjY6hMLZwvStAB4eqTAATunjoPtp0NXmO3Hqf0FjtUw2W1xZytnIpHtNiWBGShWKM0d/zQSh+O6MOXpORB2gIUszY8xywUuc3U1nQ1PcG2OS5kUl6A39eNuwn7foUFZdfE/2LO2oaGcmBB0JseMzXGTf5KTm88R3uT89+0BfUpn/EiD2sKJXC4Eqwpo9BG7XKXNaLQZjTqdvnFSb0xXKxftl6tUnlEL1JLGj/Ivd+YkrxLc74IURzt2dGTCc+juOXa6h/ndw3c73b0Y/PfVUXrsptEmbDfKlEI51cCHbrcGXiCkC3/qZEeu3r/0Lvd7C/CyOzap+GKVlvhYMj4rMGqCjx341GnXbvp+hzKbdhjMzOmlmZImzRQmqawos98cOGF3RbhW4KjPWgEbz0W+D9ZOTxsbi5fMjufTNBWOe6nr2SU/2xWcptRJRlHmft2lMPDejsQDnDkd2pqCJT6f52duvIQZn0OD92ITuuoxKT5ASWKeE2c/I95+ZnvUdrKz+iPTSiAwgWJ2aaoF3llvdMbmrm3GjM3bVafm7ge50p3XgaEJxyXa6dFlzqbHNcSfupdy2IdQuJBYJcPs6Egp4xSf+aRqA7Rcn68wy1eK0aiBmho0Tf16CnwuX0O5+Zco63wGNsyOjlB75+z6ydh+/hC94AxtHamdDWQ0SgFe+XLl+0jiYzC9Rdg5lJwfWri9LqXzXAtWTjEvAzudAWnNbW7BrceTS2V9b1dd6AkXDFVFELSvZ/ZXC1i+w6erWNiiVrnnl7XDrx/QQOoClFhv77A33KI3KH+gl9rk2+odGb8t+FIFWDMYDgU1oUAhTGmTG6i0RUFfkCL8FhNlSlqKPmTN3KFUHZoNqq/Y1MAnQcWgAqUa42HZlKn9pbJl6soXz/TJeh6ah0oKVTEH4EiUjW0bqCs0nlzZnDovtWZiQ593uyLt2uB70Qh0ttMgE5jznxhj846vu9bQvihEcQhgQ0Duj2l8SA2pmzhEA99QHTgUDgEbQcBnJI6jXPDrjYdXkH85jZR6nv5xo27c/7JJTxD+dpMKhFKKdlmkvyC1c3hxvdX0weVIdpoqDKUC7XbxsyYxZvybqgr61h/yiOANviE9M79FYPZKPD20vNOHS4uuiIcMtDerVLghM6I2JEyV7S40gsvQosR17TTf5H6zJBURZNBJr/brMj5N2HhpexDqPaXLl6JxwCMouPwwKsgnoZxdIt1xSE9osnCZi6lw7ONwkdOpV4vfAGRl7nI08i698jwv3Wdj9KQYF4RPPt9QRdYpXerFw5u0xAz712c8lg5NtMN7d2LYvfftKuUIZSlTt0OlUgsx/3orL4PrLryHt8puY+2mMy2mhZ020BUZGPM3FiStuwgsdaertNDd2JaIS6R1U6UuY/8cELhAPZtQ2A/72wWj/XDTgvnVP46dc2NzW4rFWrK3RdEQc+GaGcXeBN4qDdkb7jiCPF8X9JrYhFrRtt2CpnBPLAm3QFOGDg0UlBW48uzt8F6nOsxzME/DdjFNQuWWlOIfXNLuEHj2s84a5GrZZQIkvEMmGnOj54CNrImVY361jJgsp6IzLxU3YKE7V3xf3y87tDtsmG+fONCtK3WXjTZ0kh3yQNSZCP2nv4j6B+WDlnhwapzBzSaJRpoWNt416GOxStqTSn4OCYfLUmVo0Plq883RY/snQkUU/MkeRzoycuSVMtkDwDccE+D6eukz1Vz21+z3W4/0CPc27t2b9+TODLU5Gkof6+gq5JK/ZB/AUZl0/F1NJVPvCTzL1EkBZdx90jX9aZP6TrF710Pc+N70ghtRauJO9TYObZsCjTmRGwNJe+3RxRgCsC5EZ2oDgHtoJd+dBbu9CFGaNPCGbboJW7Gw7XiOyZiypdf7zF/8ZbWcdl+l1BkH5j6F4wD/C7BXop0QhW49aB4qvyB3Mgo1Gc3t3PReNjIjWPVNJnYR74iQ/+7bCmFj8e6nQ9racjzCuCLMeNlPf0x51FFb22K5IyU6g9TWMQ2elVACJ2NMnXGKvQ4GTD3tZ6J9a0tLR3lU3FcHZZUCzOGJFUwx2QcQSAKBluqry9y1+dIWcqYCBAJfdz9sq983vH5EsIlWxPE4Ipx2MeOedprlfHY8D+FajPSYkhmb9zjZw8zXGbXulYHqdYcMEHGr3eqbPoZvBJXyvkqNfhycgrECRtMJe7Hiyhg+g6mst3fbGU38GU3N4EztL6PqMfOXBi+61UPJ0brd1qpA3A5vtZf2OlwDoWIiJiK3F8gW3cFZ5YBWPRoFGEEtEJH32vPFSW3DU3n6VIo4C76QRbRzCEAhiEHFfbPyw+u8OMAa0QlDZrH+L+/qVjWojrXCR3FtQV2NMlCdOF7SNeElIOBdCF4Icn1nrBM5qQpRfiSvSvoBpsNGEpOXMa0gJwt2TT2lIAJPHyWY/llfHXv4rLM5tupHB8M1Xi3yoVWMt6C6y+yimBrcUlxD6M7WuURzhBUn5GcCTh7+G2BFHq0R+6sQEdZ4qkTHRZ1Yu81XnizaSQVcV4RxTFm23eVgG+hrWhgvDQNHgZGmTFsoSVmRodb9ytHh70XvkFJLcLiM1bNPzlRqGZ6voCF75xeaGJOc3O97bi11lPFL57OyBj7QiSreVaSje4rMof34i50LahEDUA2u2YGFZZFJC1W4IAtx8vad6zWsO2ZB3CcfPyq2VgxwlJX98/sdZtFuVeNNQ8Wgjl1gTgK/wGCwVUT8ktyTjqHG5S0z1iONZz4i1mTQFDfERLmnxQ0BYBl+lDyBgONPkiOmsBV2nYbm1gkVs3HDuOjRSXu5FMDr05NMRF6fZH7iccUWRUUk8yi4PAx7CkxZ776J26cyxaXnANoorLVN3li/z43y+2xfqZxVvjFoXvzOk/38ij3oz8pge1geJPdoH2b1zcqY15DdAdBfm9FIkzgapWXetL6ipbIAbfZDfxmzpQh6q6TUOMrOnZn0ZvVb47P2d2FkHIM4/8glVK6/1EUEQEHAhjcrFYrB4BzP5g7mogbu0NAejoUpGEE596PZ/W7CzDZK8eaz7JrvQA8JIGxWP0bw3yVDwd/Lf48MRfjrFcDu26vw7hAE+B7w/Hh0D7/jtF3MgzAWbjftdnsBOUIIGDM88izwqU4dKI3grkWZQOigkdrsqAPR8YdjFaOc4fbTrJPq6Ylnkpmx3oYeCgzSdkABiHgEUzQp8qqLmNlYs6GqRc40cs96lRa4isRZ+42nWRFMM4XWGd2FLBJd+zMjPvYc8U8MGqQzm813ko4ahGFwKVrsFXjxKq99oXctX/h4gvpEu27hIwNjOVgtyzwqkizwyuz8My2EMrxEc2OwsvAgBNf+qbnNMZujOUzIjzGhXNaC11IO71T1Ec1D/7i/g+2Hc4qbiPH7hm34woBBTZA8zgXvzO7kREwMC8IUsqkMYBJ2sS5XYhp7mR1HqqVHEPsoeI8eUaYRsp6eOLEVPctjiOf9KwBbv20BW191AFvNzWYUptWTGBQcPhhx5hzzoMk5gVdhA+3O58kbG4UeKoUJI29USt5oX6l6F3nVQksBK19oa51Xq3ShmmJwRj0bokndJbDeRyBuZlDkPK8PEUCq0UjTDALIpiOAbA7CHm12Ghg9Dg1rZkfTbUyztzE+RGkTQZjdBeaFv2Zi+ZNp0zW97MwqzHDjRlAI4GXrvEi5YnZmgqzUBGlfqezrfNVOECCI4jUajYZMDucazQ2z82fHstuhy1iHJhW5LhZ3cuI1046tamb7e6Fry5fu5Nn0TJ7VaKTbMxqlVV63k6dSk6f2Js9GT55NDLiW4QXa2W51jCcZcuAnOq3dPGL6bCIIt0re6g60M31N7VW39uoRtVeR2i2n/Pa3w93K+3C3XvXibtkk7/wky0IU2+29Q/fXq8A/GlSikEb27M+BCvCrPhVgPMK2smx4QUSxiAUfG54EhhCC8VBjHjOVOBUHFsiJ4CX5SPruPKN2GGTTkO5hx+0kzz4nBAfZpQj/tFISI0mT8zfvLs8uEoT/dJglZaViX5HW67qs2lhYDGB54R73VdkIQtuIWOrTGV3aDzw2JLL8hzGNe+rSl8GRL1JctfSrGE1fFwvB+F3qgx9Hbwxpl/rRKPLSgNUzebgAEM4gSvvHOn1fp8xquUGh/dMKqcvSqxph1gV87pC83+CxC49qzB0rF+YYoeyiTkmKonD5ZmRc1cM3Yvp2kxKU/aiNMuTImx+KwNPmji5UjDejpf8mWKI//JIl+lZJxb72oL2Qi96sRo8gQdQFwq/7llEoXP+4UlbNSvViX38XGkrr2PpBDPI/rrzSrd2lHL0vDsYxUlIDjPX+aww/Jp1wletgXGQBFiq2ANOLIFCdBkygFhTagjkB2eHXl8tcx7AjHwFyVibmmhbYi78t6FLyiR9X2uy6qFaM35DlO16euQm+W3mFk2U+PNGkFo242CzkPFhtqpfL/Kn+sGbsQ5PfX5EV4+Qtt6arjGZ/XOFiJQgP37YHYai3pNf2/gYCDq0cM3NguN7nr1aGpV0UN+Qdr1rw7DwprynjJHnomsgBLbG0vKuXhXCSLMmKcE6Wyd4rJSN6BUEEmQkiaDI3YFq2Kq/TBrXG44QKgyFt/Co9F4P7HXaGnBe3JnWkBHcK6RiJsrA/rVI5fyPLcTMWvLy+Jry12+EqROSBqZkOKOkMl3YgX5gouREKO8sGec597Wg2adQhEfryvLP2Ot4PvcszxAFxHBziGcPrJfAicGade2+o7T/f1a/02lZ2kXaPUq6CnRWs906z7r66Ay2vyyNA6kuHxwjfc1JXxUJOfcBI6Ngj91XeY3XnVXOxuWoWvIRIqQbdIfYt94lr1Kcr4t3VtXBAvCHQIuU/zvOkZnUjR0DpOCXl0/ZdlqyLZr1QFqWY5WIM70cj/cPruum9+5TFkihTm0lDxGV5Q9hGuKYEZNws1kSu2nZIU8X4uz19rPbWAzA1Nrzaj6TRmC3CDrW/Wg7AH/H8dJ3V2V0MamfQjvZdgxTDnLyMd22Ucr0xESsoHb5LBNcR12/oC9IIzu46y2ZZNjVrSBqQp193ksdmpYklHPs23tB2liLcP7MjPhn9QTI7eFjGzREsNfSecckAg8A1pJaT2qp5i1yMazkM/KOLz48bP5PZLXHlpP9aFzJZ0xSNRsVotGC0YRWxP8a3Baf+U5pEqhuUzWBJak4WckzxYNOQQaR2EEpJsRwnJjYU1V5JIWPFdV5NIzPbNjxjeJUb74YGafP1Rpuvg3yYZKu81Z0H5bgdytFE+SArm3TdPJn9gZw6m7FbX+Vch3MGF4FVXkSb4BSQ6QwT31JyNRqlKxvLmn0kEJ5RMosmXSEUUTb1OtPerlIdMML8geQ6EGhgVtQ9gcyO58o7n/ge+eA+6zrsvl+lw2Pwa5yog80xpnJtQ7yuDjiaobjje8qNg726AOSh46nvhGu+xjAqIqcpAhD9AiT8jOwQ3qQEzyzEQbmbg9cqd9EyTBshqfdlbkQMU5P1POZTlXquYhKxqSzS1ty1M4DeOAZX2WQMQRm321Q/w+OU5sPjLBmrj1NxdJQlyTDnoxFRfgQcZCmCMlPxDs/m3gH2PVioYI52Ot5KqeEZWmiBdqr4kqQzY1xjGOeWtoVycKfEc1uenBlQ6VNlamhRBX0UtyCzm64FgNOFqdP6FbhZt8AQaHqcnXSC5Mo1UrbXIkXeU3LTT9oRwxsHhr+F/Jhs/tAoP+rN07zBw7TIC4vb0rHSeEk/FlW5HKhyBmw1eDIeP3uSoEmTF6Hyded3R4GHJ7h5ukG7FO3AkR+ixxXhBdf0YpUW/hVaoXAuIJ6u6iuUnR2SatJOjSBxo6fFLl3E+CsmeIXrMOCrK6I+sBU2H8pAFM2GJ3Z/9NQbH+opycypTQmLBGnroNhJUWkPjMFWezLyTc4ikh3HSXlTEw4bc6It3HraGFdOHNhK7xDV3uYdT0SLyCSOjqyUPFMWSZKgPKfdaXe5JgNOftqQRpAlwJQNFoyKoqTNIDmiR4kFninEACbBIDkCD1QSyGvO6cIPew6OsGFnuHJqTKvTVXm0WTqyphncrhINblZEHilNaXSIMcyhyCTrU2OkNKKHwcSeJkXUPTYc7TDE8gcbw/myjp5uwUjCsTJ2JvJkf07a6fRQYoh1vG8h3tmgXby5GZ0H0gl3wCG4gTjgCIsdwCXELH6ck/m+k6SjttrnryWmKRmTT2SxEeRCL9Ols06Fhrq7KRsyViPvajJd92mEYudP1GlHlxvsj9zltsTe3sn93GEgQ2AD7htAYVFXSeCvC6zJMQEEOax9tJb8uqnG7nyoNltZnXMYVrW5h+fPXJdTtAir/mx1aewc7fws/yilpU4bmCeWOZEnJCnq5UdHHdWJx/DdIYPD7n25zDZYkZ0JDG3LKFbUZwSDurrJeAvUizmR6yorsJ59WbNDuAnnYLsO2xb+HUJid8x0+2f5PrPkcqnkbqAULE0VrbjMWxzhIjf14iYnenhAyoGWypNi3waqFfUpR3iRD/0D/XbrjqzFB/CPQG2CSZpwUrFimRjdVkQ5u90ukFZzxcgJrxpSjqZpQoprwhNDQEdLu92ycXf71cfRhoivOLttCIfi8HDIxq1CB1OEO6oROQl/XJj9w9PQVAg3eIMQDic0Gos1oXE7br6hugNIWmFFQpfeDmVY8zVVcokLhLKF7rtW1HlMZ4ZS0jT9x7f9RP5H8WKVVvoc66uBWxxPv+Uh8TnHpeL8Xe+v1zHJzQ+X3niXmWwY0cb29M4fFyY6o9c7BGEncujg5YsB2GIPymZAmRiQnzZFNRAMjLj1Ehq0tQ3K5SDpcrVIZw9PEMqibHKDK22IhOs8LadvN+l9UddVKUUjyeVMz2blThXx1zptbyvamKv+/QHuiFA2AVLxMPeiy8SHIBSi2WiUMg9FHttvJVgtmSsWhaD1YuWV17rvyANVzIelddHBodJVsvXeSyLc78/T7yfYnTR/lZOmO2O6pFCEsDtqoh01ulPecN3eth2aXDFWkYK2qhKYBiXK9BXdOHJDl5YtUq6vRWe4pUSuuYzgdgFK0rpnHoodbTnfdXvJ99qLuxGXq7TbEquQIBPjINdSB3ulaYVxaVuAOPF6lVLsqyVtc2OzP8LGGv/WC+I3ODhSqX+vu38AY0sl2l6x3frMYJjnzPH4HJ60KmanI3guwo4I6Ze98peDJiRFmCOEFy5eVdodMtHXU7ImUh9aExbB5Kdt33Gs7XqML7PYufMnxnoO7NKp6stMjP0aRqNFCFmVRponDmqeO0TySGM3Odm5Do5Wus/trH8tReiiv5YuYbALRLSb9/Gcfd1sGFHXJuB/Ch/asy6HJxMNZYk5SOjOwgRx3Jth1uRx6k76Uh9P0vamtkVUVii/omOHllLjwKidrtqBvE+rXL9FnchYOpvWwXpqVtd5Ox5gkfZ7aHEHq/RRrlrlKo20rgpahTXd9nypOqhC/wB3LLdGsCbuBvBupHDLjJO8sDaGZpSU1t4Iohq9K9R16xoAtVo337EiBKvQzts9oZkLMIgcWOgh6FgzDwZKA7gcrDi7GRSDZblaERBRofAEqXEJgPyBhuDdL6bgthRrr+ZWsW4jiqCJaXM4j3UPTRzM5An/fYfiydERR8RpyYzPMXWf0E5KCwg3O23wbYLmadurdGP6HSkrBv1+07r+mhdeeAD7tgX/t6+UV7DBQ8Ybx81nY+cVy/csw2BOYncSpjEbKpy6ARKQcr/GKc09QQlNqYazVMI4MqEA1VYd7MibXRbjY0qzEybdITRpxh5CV5PWvpyGOypSho3ULw87oYbFLy16+DORkNqDEhwDSdRj2GX/Qz/QfSAp8DzP68CURytfWvsXeJzUocmXt0nU7gm33nPlERaDSyQzO9ZXFLfGa8NcFRbqTYrttg40JC4FuMFcjflfV2kdm0YUi5jAXHcFZjs6UJArLS/y4bG6Zl/kw5NdqE1A94tpWrtmJse47tqYcFx3Tl3fLVL52pN4GArfhF2JEMKAKoMySStpCHxhz71UKYpU+Md4hUmiijwJrerKVZoWOUGjUTGm16364LmU++SoAw9FndYDUTDMp3RpXIHLR1BExjekaYprYghTIM2PKfmLnpIRAmlgk9ae2SkYCdrNWcqiyn2giJiutdOx4yWr/fT33zb5xmzjstFD97YQ67OfNkV1yVKOtlsdGc8m1CIjND/lEMHVk0PpTiMg2BzXrCddxLjK6dV4sIMg+E7EPFTETUD72UT0nsk1R43O7AjxkXS9tlh+P+4dq1Aj2e3LqEWZCaSN/3qYx0TEiJi4AD6qzx08Z8NCVRoPiTpmjRpB6oogSivlg9pqae7XNfUfHRRpNZmXDoKjgRRtYHEShK+1oa1bjcJTgdf9OfvwOJ2Ue1YgZoch+hp1jQsHMeEhQGeTEsxmYi7np0bxlY8KuJeFwL0PI/Z2xIOwvp6WGSgYFiD0QliIXJ71wLCojStpgkB4wKEG9WLSRZd1h0HW3MaC0IC0D6SnilkP2IG4tSEgy2NgV3tWj+e1ZZGKrTg51XTJr6d0eSEYV3VdbK6EMTHIeoh/Ax2n8GIDuvvKizsr7QFTtohZ+vneROHRQCaqqlQFCbFzm1FFW4tut0zRpLeLJJWdvsH3duKck1XGMeTMCF5oeShjHSijvj7aiwv4QOvtHbfC0i3t8mxBcdszfCYmsTVotAMPLcVSHkm4BcK1i8PJmMoE+zs67JXfhlfx8EwimVIHe1xS24E73dTdlQC2fOEptA8vtYgWcPgR5xAOdi2HHj/Ix97w56AR6PKz3h2ln5U9xMgCOspV+hAVfa5BnvOnY3Wo1UxF3pfPamicPA+sbO5oo8A7p+xO4HOiSCFLiERsTjzlWOlCzskqdyIUn5MV1sqgvNA4xRot3i4e80uXkAbZvWwI/2WVFgav2ULP+GZErU2aYzH5myAP2sTtULt+th4uIWgNpwZ8sM2hvS8NuKOe1rrPuOw9A/u4iXaanok/lGKdcrzZIyBp2LvHzGjIQFHotfgX8Fq8XqV2WCI86C8rpS4k64ccEb3DQhCMJYhZN5tjbUg4GkmpW5wKwcurjSApG1O41DyrCBjMJqK4AnPBBCfHbQy4g2IuS0JelfRDgu8b19OFtKFjdAw9FXBt2g06mM3IPJvNP0+w3a5TQ4Qy5Sjxebwkhoe4SRj/NlVWTh7n2MPo86pcfOia3MUMT+lanQe6n5B7LWKSta/QzrOjUkMbsxjdGGtHhIfHh3pCyRz7vaF0hb49qjeH8H3rTpO1ebDriQGvXa8Q62mi9l3jcBMZV9sn5hvCkVHt1GB9ckJ/nE555oM6nTw0AXbgorQ/qmUr40weYgzW0cl60nYZhpo4ricUMaqfiHklQfeeeex3C8lpNqBmvCz4NSgOTunyW05WqWzz//KVz+x99evYCr1+ozlD03UX7B3Gg535ml7Pu91+7uZCBx4P85xst2K7pdstNzetx5OYlxPUKoDi0Sh535BqlQxz522bXaPW/VPZJ0M4xCOJd3qnZ9fyZXRRy7kgRbazT4JwWlSt4Z8ip+txujF67/9l5L8hI28FQrp2wyrnMLuHQ6JwF9eR2Fzh4GsQ1haXWXF559lIwe0rI3HCfSZba8HXHkNA7JbbDevbbizTNegV5HbwfVHH1KFyuZSV1lKoI1w/oEzsoEfQxOhiWqFW1SvFWKXeCzlIW6VmR6QvpIanG0ET8OBxO7VTdkcdEXd9sER6bCDsMUzixbeHxS4rtmWQDtJ80HeHNdnQt92mQiGFrKPdrAyBwipjVcVarLHitSetEmfKQw846thpwVJIAJYiwpluprnk0y+IULEkmX/AWzoL4n3hGSI4X8yHsxZI5QtdXauxinykxQ3J+XZb1zi+BlKbDDJEgS32bad+l/TM+baSyEb9kpZeFO9ylQ79HvLmc1ChGwPPVjKBG3HgQIBNa3nK1GEx7nusU2sNsHcmJyakox1YNXlA+3fA5uTE1urboIZBgz+LbGgVFN1aI13csZFRQ2hsxW3CxPdjtO/HRuL+LLT76+C3bECw5H4D6l8UotgvmQQ0TGMvW0XYshBFdr97nFC9DMDsfm0X+per5m5i4qxTmzo+Xx7iesGmUoTYefYmqC2RxIsLDppyohIuUjJes0b8uSS3vXdRQXftYUp2rU2CVbFULDBFv4Tph5x9TG5KsFyJK+Alt+q6ikJJDg/qtYYzxQwKOigqTorlXTvkGt/fjHxIM9Fm36nIhcHc0MzSRh16HihM047JnB8mympkjbN1l/OHMlq7Azg4nrAfFmvAhQhngg4gE4xaACG00HVoetIAI83AbjIU2+7HNwX/8DXjECgwnAbusPawU2NVUDygcnFkbuJI11ZWEdjpw5zGtvnrzvWdSZTnea33Tn03mOc5W0+79WROLUrUUnemsgnN2of82/SL9THyauXJ1xM/y7gA0CpiT+045Gpaqs9YtxMtWRa9+GXqcjMZbSghVaWLQcdarMoWQ02WGfF6IFEMNeFZe+1NzWodVDiGvkjEu/qtJXCf03XTgebS53CtwINBex0LqDYItHg7hF2HbYd23VXp4Q7XnfH0uLkHw/kn4QsM2ue8vTN0dQvqrunzK6O8SuPhajDLZ3PP6L3MC/Aky0tr694oW/f2lQGPdPzINx7wKVimLwqANB2NNsGtmrWU92/VmMKNifRXpa/PcKUh/E3E4/5ap35pMHAasZDgDULZxjL70ai/ZoI3DjS4Y5RPe4zym9FI99dolPK8bI3yuTLKLz2jfAuMERjl/5gyzZr+4seKIwAWEJ2XHcyzPXi3XT5h14NjB+uYRnhwr62PmdgH+Cr8Ac4JpmH3moElZmB3OiS55In1QxcGFjJ6NEppfu9DNxoW+bEktzXj4mLBWeXCC8P6acFLi0a00KNgpwfe57mHr2KEFME4WbbJFZjz/S7G9srgpJosy0aK20vrB64pGTdA4VvWlPL5HGoBYUHbWYQtkRz121KmulOvnCxpclPQTVElXp8o0aELfKiEFVWISmOEjsZ5F8mngor4GWNYc26K/dGSI9w+jsYoXEb/42KaakztGdFjCYGiwi67Jvq36eZUHnmc4RaO9ful2t7UId4MubAP2t7Rf/aM57NjlInwWik1BOZiXC5xC+ThdFIqzJLgAdzk6UoQfq4R0hvUumF0zAQjg/NbdH1Vg9ax1v05TQSrVUSjB+f1NDJAKvEls+MzO8bHc5QlhKpVc1jRo9EhZbdko0yMC7pYMz4axatSX1VZJb3eR/spJE1NiSjz1vxno171TGfcI9Op1xiSd0W4qk4J9gFNfY44bVneLOCH80wDUD1CmunjTAYgoudzDP+yj1npovo+d2Qoufms1j6s/fn7529ef/3ym3fnp5cv37xOEF53Unz95vz8zZvL99+8Oz1/kSC8XOezusL3NWcfyyXJXtd405DnVdE02Zt61374YiU/6CNu9n6Nl6RustkVxa9rzNa4rvCfCb6g+I3AP63wao1n36zAn+UlmePZz/b3fCeT23Jrr9znptwvVnOn8gvaUvWS7vBijas13jjFrNYyxZ/B/u5eLY5LXixKep0NT3a7eXsj9HGdesEulzRNYK/nCf5CWwbd7dnW3YPUivFzxoTnzGkKvzfu7hnBmkreZLPlGt+upfhqSV+v3R64Mj0w+8J0Gfw5hZ6LtpdCfIj2W1W5Bd6YApsKQzilc5IutDOdHJrV2i239oi5bocDf18FSRtIevapbITsZjA36wpt09jLrFo7BS0pvtlUosyGx27lH9c7PPvkjPEnEU13Zoj85JF36bXkIp7orV+kbczlejefgzpqxXgQqFw8MMIwvJDZu4m8XgfI+VSv9jerVUMgtnhDhHpI/W9qsGpTQAuzfxOWGZE36XjTkG+LZj0FVlApg3CY+ep3W9yVCcJIuso0tUQ0gIOe9ykayAMDWQ7Ebbkg48Gr4ue7gRKoB0psbgbKTBSsK8IyVFB55OLb6ptaCNlOlklL261zkTuz43dHvPFT64E4A/zTKppg3hb8fh1zWsQLR3jfjEbpxuIMq4hSXyjgQC/n+zptEJh8V6NRGnUpzCuEF/Ax4iezQHjjOXJBQi+ggP9dpu/D5IO8vXEH+vMBDS4DVXLYKn9VpWhS7zdQWo0rdq3CxeoZM4DNLBskR0rcE3wDKgjQZmJIn3ooZuad/gGFndGla9G0iaFdQXtjIQqiqWUre9EfoKj+WAZ7cspiO76fZi4E8Q4iKWX2OASOmjLxiAh9eRB2Qg89X/uRhQLkaNj2PvVue1oQsro8q9srhdPTBpSck2ZTiTcrD3LiBaNEB8qIunXV9UuL8tIHnO+eAjxl1qbqgDepq8yOg6sOTQzmwz0QeK12ICcQdJv4lX2xUnGIvZerNSx8Mi6bV4Ce9ELL0ylD2237+oyat0gANJ8xy28FcMD96wQ9QPyBMAdtceBNbU4Iw3hpvSC7naQDfRaA8MeRoo6SJ5Jx92KNRIxsSDBzpkbVnKXhp3x4rFqmjrjxeYV2mHcJa6NZdJxErxgTjeBF3Y3U4JtyhGNsnAm994u1vcvx3tdrOVG67+UEKiPvryiakDzPy/aSqAEocXPZ5U8hgaaR4Uj1XX9nHgo0GrEH5hANVeDgLCTrSBFmPZFAUode+QyQ0g9wAu3b7IRa6U0py66IIGl4ZAv6I2Iio4HM3nun5U6PbbfD474vVgaIfI1TY/p7DznuSo/Tc9JboydTnvlM3eeh46uSLlPiyHcXfvLOIrA55AK4dM6Oaid3yk4Q/rDOv+DpPaGLom42lQo19CVuxF0FAWyxuc936D13Cfi+TI/xLCUpShG+YOkxPvmP//zP//zy5D+0d4f858QYJz/VF7VYO1rE/kEIr8v0BH958uXvfvelen+MyzWesTV+TfHPAs/+C17P8RvqlIPmgb8dSQU+wcdIRwOCDnm5zr9iaUKvnzoWKIs6hsnQbdqx3ya/kG6Tztf4w9o0599/d/J/bGsWtZccub93+B7+m80RfhtcSp4Gz6/37PVOjDV188z4DYz78nVxQ1rjOq11+flOSTHawGFqX4MFVCSigKtfGa9JIc9NrcWeAf3/G42h/jsgH+BD82aVJpkCzaF/OG7d8lTc6GNMJQvmY8FesVvCnxcNSZULpkpAj07QWPDyJkUTMb4p7q7IBRGvvQZDpAFsKR2viyZlaNq+kLybIXVDU6Ks/SCPcgzPyjna7dAu29vuAFy603APWxqcZb02TTr9zOF6Z8bnkoW3cYLTkDwu29bTcggXKkmHMQ1Ijolx6yKKnG2lRaMHc/uS+C1BHRvIro2mKmribNTuWIQFWrlRHrJt8HMxO1bKQL8+OQARkcVtgfJ9WHF2k8bWh7pybGItOa36Ed1j3RNrjTXx9KVnQvtMCOAapGKUpPfy1JURrPxUBWZ1lhRJBBXkF5XUdEpS2AK/qLBlp7D4FI3pjcPxkJNMIG2/E36Ui0B08BnCK7GQJRr2ZuMf6Wf32sEATbD67ms7V0xCg26iH218JMM2W2uplsG6lak3cb9qc7cJiLEqIeACRRl2OEsNuX1RN0lkFRA7YYF9oTj78hkPxcSb5hRJPhQbHZkyfK9zdC6U5HzyVHVqswBwzEl7VWx6ORjLh4bSfIKxw9TtynBkttvZHI0XjC4Kkc7EHGHaWbJmcCJdTUBBErB4Ha6JjFmtIzYVSQZ/myQzu2IbFj3cEJROcEbnKiReEPNIzeuefYBoS2rFcnmeJoW5epp2GJZABsNMdsKEw8ao4Ys53qiRdjOpJejHk1qqFjG3Rcz4zUeqlN+HpWmLbF9a5uV4VVaC8MjygJg6zMoQCmdWdYgGozblKyZmI+qGM9F+RlmkUaXryvzYEgN7SL2m+hbmY3aofcu0BbjrWXVYhAvX2kO8eZz5GaELtiTfkbvYpvhi3QlmotKDEvfAHEuypwb18d35y9YGMp6/t8a+ErxT2gvv2EUjOYxfW/rsX//9+Nl1iZP/TtyX/3YKLzPv5Zf/Di+/8F8+h5fYz/4VvJz4KdXLIz/lC3iZ+y+/hpdTP7t6+SxRh6O/7ztO2DP0aJQSq0fXmnM1eY1Br3LJa1xnKsnSYUNq36lOlGK+/rXdSg7/Zo0JTHqlTNZhtuQLJVz3mgg3NVmUq7vBFRPrQVvAoKAKplPL5sZK+KaocwB1bJMavZCmB/P2kOTI3sKcbUZ7jjbCPdrkiTy/NBACTExntJ3QgIKfzDP/nT33CITw/8/ctzDFjSsL/5VBJ8VnH3qGmQESjll/VAJskk0CbBiyyXrnpDy2BnvxSF5bDrBh/vstvWz5MbxO7qlb5YKxXm61Wq3ultRNTPIt89jGyLanMOZqEPWGU/Bd6o2mULjSChVLtl1Ifcbn2gPnZTEUwreMYmgmXhXD5Gjp1GbMIWh32whbWpXz2HSP8hYVH61fNyb2PnH4QrbUXFd823Bt8RSdhH9N6CNP00B4dXkJq9Q3VukYj9AEqla75P4nKCu8QcX+n6ZDiM2PH6NEdDX1dC2iq7W2GqG3mh60xVCNg0RZ3RusQblq3lcrmlUdr8XlILJ2A1om3UAu2mi2IyeuCM/xJ42J4Bu13w8XfoWljjftmHxqWflSNhhtne9KvQlIyZtrnPpeObdLk1K4lg5Tytmj1RuDj9igomfVQdIly4TaUFWpatC6WE5tbJQOaNSsRqzUm1SHO1tTkjm7QzJXIjMvsm9QhNxLrEvMRB32rXzYlEDK4kCasnI8t6ooeared1lPi5PqS7LiUtvJmoBwAITFTC9BurW9/mhNBA+RUTkDbFEYmaal/TaYme10wrBcNofKNW4aVJLTB/P2dkHk3bSwchAseNurYj7H2fp67Vi9kVPZvz/d09yrhM4a7fCkqoE39zTwM80Whz7zG43oZIH09/dco1DO4iqJKEv0eeAZDW9qN89TmrHTjF5kOM/L3dermEUHGQ4xYbGf5OaubEpJjkVkdvRnTok6LLzALKKhiCV2nqalkdRcnbTmqYj78Oj90eRIUfjro4n69ebo5aH6eXI6eXtyfKbefjk7OT5FTum4X4f+1Q4ilkvLgMS+vc2USCF6XIbNI/tEnt6jbmY71CVANSdo4kLGdzKSVuBmjTbT5DZXianqAwb26kVsoFoh0qW1pbTM4GXkqQFdRL65OrmhE+tI8KbJ9TiywahaU4ZlkhkhTEU2jitn8ZKYfotZJB0wuGyvdFTmu6wSOve1oNsoviEj0fr7aB85/k9asu2P9tE6chCyN+Kloe6qHnLQ/4ygq8HuOzjKZ8YrPvYdB/2NRYOTxz5PcD5EFcHYt7ef6q9v6q/drkxEY+Uvp/xlzuQ/o6qEgWynFZG5LHV72xEbpcqsy7UVkPt8ygwknPHczHG6AGh578SBvFAod2TfCCp6MDJr6JJJNYSaOLhJsRRM60Mga92BaMTwNdtMEz8maCWukXDXLveqN6/7V1dX/TnNFv0iS6QAE+4FkZ9xWfN88nN/F909EDLMwePGoQaCYJod8nyH5LU6Rr1kcsoaLV+EE9EiS1RiIcIPshqTqW6flkkQV6yRKfJt0C74ZpEGp9tvpThdTBJys406V91vJjgd3BgKl1V8zWRrMq6+YAYqQ77s1Y4ziu/mmL0peWzhmvqlmdmOyoqN45FY2ZPNGkKNFLH2ROqpZtJJ+xsqwMTDPyEryC8ktjzGiS0RsAakupI7CShkOAU0cJmDOdwOheZw+aXh7Tzq0iaxhwdnmDB3OHXRmdhr5knnaUL9sFwsR1MX1ZNksY/q44p7jKcuqifJYof0itTa25q6qJlYb9HdNtpSMOU4c3c4JLloeGl9X9rw850uepqXrORcGw+HRkQ7afRGJ+9QfYF1cUWScnHV96R8VhgUj1XKvv7hMLPgBF+zsgx/ub2tYiG7WE7qSmSjl65R+f9zWPXJf5Hy09ZwKFwD/V0fz1JMZHcyFywv8Al9TW94VQoeZ1XuedQYVyjvTFOxDyaDAHczNtw+aFza9ARxM+u7pma8YsorLN6F4AofUCHWqWO5MQZQZImD6zxUn97hk4QtrZ8jG179F9AKpCG21nmzPK7xY3EuGjYwKr6Hm2vB/+mR+evOkWkPAwwBnZNLQq+INOai1sAIH0HoDWOpKFDxG8Ln4doIiI7M4ZL6jCTGdNwXLfTmfpwUGe6FhbAMp36W8/9zmvXQhqVWb2QVCqQiS2xkO/W6mpvfU2sDOT20wRQMG8h4EQhVN3FdJv8r/tIiKYHXSpf+NTINZ5JkWJsmgM6EzzUHD9QvUAsVVotzc5XCzeW+tmjhusjSXMFwU9qQkUpe33cSOVLn2DvPEqug/d0uu40dh47bEjW9/X1kZy6ulKR4L3aJRpRZ8DjaL9MduZpYZYLkIloQ2yOVHui7+qUh9+pkR+pO1vfKMO7ovKVtq12G9/IGQ6UmK1He4DclV471aPrNYSR3DiNpCKPKftAcTtIaTrk9lLunhZXZ7fD0FXejekzVf7klK85U18fk9hbJOwhIbGIrKtX+rfM9ffH/oR4YXkUiQJa0cJTtCb0tvEHK4iF+O6pQVlf/lcGPaw4zYXHSlo5esSLSoTJqSg69vr5m4Zb2Yxiw7I7bOJqTaBdGxKxQXaTpyYZ5B2U3Ejr7EdC9SujsIWCJgqvB4TrgY8HROmUVJUxqag8ARtZcDY5U7+rGqW6wmvWXor6miqpLpaWrBd05ybAfRMKrVa8gkubDnqK+Hu9bD22U5LiBlqgdq2L1vkhbltFGQMEaLW3Cg3bsj5Xucu5t8/XRpKtBznue2KKwKHY0yUcqvWNHqGxAWh4Bl+qWJVmqrba7LAayzNeDl+/fv3p5wPUEvQTKWV9nhJJImptK2lPD03qpjaUdHU191nAPdvdtv3rDpy8nB294s79GXCVteeWgHYvkg9s+OZvc0XTxH7R83myYa0S/3XknV55yEcqYvprEcBbglHFBqXtXmM+4O/Zgy/rVb+0Wh39Iw/V7dU7+zWRy+vXt8eTo48HR6eTk4xmy4d3jTsSUn1pB3MbiKD//S+Ru/vsP+4/pH8v/B/t/kE141jjp/eVxEMyK2m3X2l3pzx/ec4H2oxwpBcHn+2S16yhT13C7xbWOkTCONcVzPYvFgTO1RdDipy8Zw4uU4bDHaK+8aNj7hTOKniItEfiUFir1IIkxYfI2qlzbkgQbl1BF66cdB7CZ0SOJLmluzwY0xcTSMAKum7ttaAm7IkBPa09C3HXSJ6zap0QMchAnM9RoSG2eZ6v9YUAqJI551hq9DDh1cWWpo7LOhZbVE3qVvRZ6/9z8J7JhrdG0Mjj3OZ9Etg56tNIcbdl7ammnKmRGA5hae0DtpTjOUxe95BZIPbVxajLr2vlac914P3akBCKDI7qNvQfLBnUOqWg4TFRg53WZk7mj8XjLdd1M683j4bajX4CU6VJNRifvkHLid8xFSnkmpG6byS3bhrjrJpHu0vnH9ygmMlKqkbZfe3M2//25r5DbF++LAeOsFq/86r7IqqdbqNYKsqUlXIR3FLRexsAXvfo7qoxBFErjmWE3IMI2EPPFNGkfti5ETLDScgyxq7Vg8N2aQpxL6zkkYrj2xsNtPrzChlsuNhUV7BsEwaGoXuW52FjEqk72x8OhM5TKW+DGyjIQ/7Q1lO7wBRkJllTfLmzteagAuKmb7CVuUh6h+yUChGT8zsRFnCATuekjnOlYicJuFcbTTcXN8cBdG0FS+vYCTsFOsrSXy2DfIlXM0FeRsgtVBuZyFGJzFHwxCnllk7GBmJfuHGVvEK3+FVnqy49vdglBB5Ovt4p1W3qy3N4OzVYbc6huAVraexpWvjynHFPz2rZMenurcVTwuZVybqvDE/Dxcs6jlkEbpEcDh0kXY+FyT+98HtBFWjAuw6+vW3TAKPMTl8n/Nkjm0kEidQIUVVM/49xfmJPr2Xw0BMDUXkLX4d8S7roNX0ONS6hxF9QKWrH7L6BWX2NVgIVs4IcydFp5UxTxNhEkNnRliiFAEMg7u6ZRQSx47QppuUswL0/8+DK6SSL88+lfd9aNbHlWkYSWX/ajxM4ZJmxp1zzHDTK8oN/wSuhXFCj73tm7zioP7+A91WUf/RnNmCUulUkZDIelEPr57OPPXw9OTt69Pfp6/PLDEbKBNXK5VnX0UeeSsC4vZuEDPLKGNNCSdpr4bE6zRRU9gF7GWNzNMRzXHYhUdfQOoSpjQi8xMU61CPZ3QAvC3OEKb66ySn1NRkJly0pnUBoqM+6Z6cY5pIGC9PYWodIgsGb4kjJBNk5tKOg2Npp9OEi0flChwF6BATND1FYDSe9AvkI948XPcPYtDkqfuJIVC5x3Kjur1AptWC+ypCE1cZRyfd4Qum9vpT5eSxKm8ozlwqU8ihhLnc1NLl62M3KRY7dVmT0j0rTZu3KsrUomlwcWMi5xmMJnAwv27a2FXaxPhras3PKUWr0OZPZS7AI3Vaz4/jGZ+cElJmHL5y0rXSfH5I7zyS39RwmZmphF/dV+CX6PwJuqIzvyU0ztUX+MLyLWrTtwjvBbpPwYm50ovSZU7bVQ4q9CialTqmvubV1yheOk0mkPDSt3X++ipXTExNWkk6aZ5U4jy4rPMGN67pffxGHlH8gssXS8aXnhpV6F1apUJXgV7f8J8gZ3LVYSk97ZYCzVdFRkiXsk/MRsoM0kJrhIB9L+1M0Y34siqw6E85blWU/VtrDZkIu3gpb4UB3iuTvH1ve58prVbQXA1mdsvY64QCdma4Xe8C1xUEYpQzqiWnJfd2WvSna2KkxHM5iGUfeZ226oQkbpLS8IO/wVDEt/BR5C006fBWn4mIv9eeoTBJ6HAk69CNDMDy9wT/ztp1m88LMb/RYnCf/mHd4M1IdOYqs/khkeenOIpnb92n8J6/zhsO4CSuIapEmcs/5FRou0HzO8eBhoZ9QaNXEwu89JQ9Wtse4VAuT0eMeMzC2d2UOAaplH1Or0FSH+paF0nLADo+dbu9vaccIkAe+YwEsy5Yzh7dzxhoD4DzRVXh460f3HtT+sffuMWi9ao77wk6SGTC769xcFw+GDh3jXwIUc4jrfxhaDHRgC0zF/Bs/iRZrEQcwGbw5N/+dl8fGK4q+LOMTH4jScDbzg1p0FhRzDi+2uKHb+8b29NOgwejgdbgEK428PpJgWtY0BFckKKn4Y4u8kpbkipS0Yv9jdGe9qWjrStAQ4E+T0M81ONEWJ3yVRdY1iHducBktHIyUKw4ejcEejsMICb9uPCc6ePouj0cOncTVdTr5xBoyvenTe4xw5d+6ft4oJRArZ24+ft8wdbY2GL8ZA3OMEMtc7IVMIBVzs1tUfGwIRB+xbY6JPZlbRTvgobcMQ6lsYKkjiORnE+W+Zn6Y4tDLb/p6552RQkKvMT61MmxPwIMTzAaEhzr3tqXCtE/O1NsTXG0OIjSp4QJNQiBG5R6f2Xv1dqG7nxIpLuSxbWgw4CeCYswR7wDKf5FzZsYheE21bk1R111KYOb+FwouNn6Z9WbRP1ZAhSMInObPpbKtNOmEIQah92oxG2893y/mUhOAV4WMc8hiebm6euLBfPGJh32pPsbA/T/B1j//pBzQpFkT+XoT9jF71/CS+IGIhzfsB5upXL+1v9VJRYLu3mPW3erOL/lUUM9yb0SzEWX9GGaOLXh75Ib3q509dgrcARTs1WIn/beZn/Vnmk7C3uOkPe4uMw+EXjPbmlLD+FeaaQl9e+O6lVCiMaApeLTYs2ixB8jzxDwVJHFzy1M7DNu7aULv0lAWVgJ65a6M118WxhWFs65iklr2+ntmQLZsuncZ1loAj8J7NIZ1X7pyuCRxxDlFBK/iEAXxzlT+j1lYNbUNA8eJC4M1PmFiEwRzumHAi788SGlyq4WU0FYUigT0EaGso3vMsQID8PMcs30zoBR3k3y5EzlUcskgVfDRz7U1wktw0pZGdplxH/DqlLm76Yz7qi7Ac+K0Hk9bz5nrr19pO+2OxM9QP/eyyg14kX+Bf87wRIBkYFsFwyocORRmeI9gWuT+KnF5U5EQGs4IxSoAMApYl7/CNOPLHfPkrj+I5e4dvVlHdC3j+YvRiuyQ7VpIdp7hHkFptEN8rjNSw/K//CMv/+G/idzT8YQgeDf9XMCxjeTQwPBq3lq17UCyRV1quLmIWFTMuI2wyPg3ZN/lflNV4R19niU8unzC3X4vmm0Bv/yifeDs/yCkexyLaRFIdeCFe1BSXSSO+cKJ/6LcdsWS3m3mupZcXtgoWXb5ytMva/9KFOMmZpfi7KKZOFy4qmUYYH2BSPFmQkQ20EXoRwk3Y6ZFvUjzMI9+sYQm6CledkBHbd751VoA3KaZdXakdlVZhkZj7fQnE9abApytQd7hHf9J7Pnt0Y6PcLffodC+WllbXdQO2vr4mrwqKm75yvg9tGA1fbL3YHu2Ot9fjwTzxL3Lh4l14uZO1bYjlrUGXAvN+z8r0qRsrabW0JQmklGa4Vzfv8I3DDLscBuUx3CEQ5x8pZU62XFreIbV2RmNOpq8YeN4ueG8j+BbCIuRsbQv+ZlP4lU1tOKTW9vPhLpAQshC8wwTeMsChkUND/ngkBKaSd0bjIfwedaDYw9MleNSs/iXijydTno+2t+FZpKbvl8go9znij/csMkq+1CU/myVPI4hD8F5G8Akbya8j/ninkQGkn0GSgedtgZ9NjbJXCXxNwPMz8MYwS6ZGlTMGE6bhFSk4gzyrpbAMijJFNPghgE8BR58B/WGmoP8QGCXfBvAyqLVGgpbGpJ2ql3jlxH0ZKIoXFxj+DKxM/joOLF2cY/8wgS+Mj+Jhwh/+Pca7eRqYGMgC/ngkgC+KDEZbO893h+AH/Cl7IgpHAX+8jGcZHfxKVAcjMzUOVKpvdjsn/PH0x0TH0zkciLXLKJeIIBUmueSaCJKoBmgQ8YevfDJ+xicMuUkmhYh1YSI6jeBC1pBhGaqcSQRnEXjXZtopW0ngEw2JmOvjra3n4If88VrpecifdvpJwp8yfbwNCYNfg1pKSNohu7xvkSWGuYQUriP+eHoyiKrXDLr2LzyLuBg+J2JzdIYRsMAWrwHNsNg0yhHE1vcl4AAsIt1UtC/uGZ4gPCZujEzFBv4lJoA567ZtuyPaGAuWNhyJQA/yjtASPG8MIZmCgXk4YvzhOddsqod8tLO7DTPCH+8L4yT9CXOU/c0Lt7AbZPzxZqSV8zrgD+cIr/V8EAiLIphFIv3ZvGIHcJzCSWoim0b8UQnjnecwj+C7ihXhrA2X9SFNYBGBiCEyhiCZmkQHacIfL0mqpBPGH+NrZwTeEvBOxAS+JCbAf807iMP7nvoschCCTEWSmlCnFDaAZ37wWRA5aF4kCVqCKq8LlLYcJwmX02m9N8/m8DWCO4PXjOH1fMr//T2ftlB/E/GHj2sUiULPOgrNQv6058tZwR8D7zgEsS/fn5y8OzpGZhbjWf0VmQGDtSFPmHJByLL3jopBmtGwEKhcX69vkKcdPt+V+yvpHrvH6/YWNMQ94cS9p7fQezlmRTpA9l5A3LXR0rLhr8CyK//RcpdNh7+9Cu2BPLXUIbgElOQ0weqUDuaALwWtDqfTqb33PwEAAP//PtgDIw1SBAA=\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "polyfills.js", "\"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\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("./frontend/dist/telly-fe", "styles.css", "\"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\"") -} diff --git a/api/a_api-packr.go b/api/a_api-packr.go new file mode 100644 index 0000000..cecd855 --- /dev/null +++ b/api/a_api-packr.go @@ -0,0 +1,18 @@ +// Code generated by github.com/gobuffalo/packr. DO NOT EDIT. + +package api + +import "github.com/gobuffalo/packr" + +// You can use the "packr clean" command to clean up this, +// and any other packr generated files. +func init() { + packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"H4sIAAAAAAAA/+xU3W7bNhi951Mc5KoFVC8Ntq7YVRmLtohJpEDRzXwpS7TFTCYNkW6QPf1A2WmR7RGaK0Hf3/nO+YjT+cl8eAxf7ha/LX4nFddk6U/Pkz0MEe+697i7/fjrh7vbj5+RG2cD6nMY/m4n842Q2kxHG4L1DjZgMJPZPeMwtS6aPsN+MgZ+j25op4PJED1a94yTmYJ38LvYWmfdAS06f3omfo842IDg9/GpnQxa16MNwXe2jaZH77vz0bjYxoS3t6MJeBcHg5vm2nHzfgbpTTsS65ByLyk82Tj4c8RkQpxsl2ZksK4bz33a4SU92qO9IqT2WYVAosc5mGzeM8PR93afvmamdTrvRhuGDL1No3fnaDKEFOyMS12t63/xE4IZR9L5kzUBM9cf2801afVTEjReJQop8jT442smNpD9eXI2DGbu6T2CnxEfTRdTJJXv/Tj6p0St8663iVH4gxA9GLQ7/83MXC5Hdj7a7iL3fIDTj6teU2FoxxE7cxXM9LCOpNALnSnBh9i6aNsRJz/NeP+luSBEFwyNXOkHqhh4g1rJrzxnOW5oA97cZHjgupAbjQeqFBV6C7kCFVv8yUWegf1VK9Y0kIrwqi45yzNwsSw3ORdr3G80hNQoecU1y6ElEuB1FGdNGlYxtSyo0PSel1xvM7LiWqSZK6lAUVOl+XJTUoV6o2rZMFCRQ0jBxUpxsWYVE3oBLiAk2FcmNJqClmWCInSjC6nSfljKeqv4utAoZJkz1eCeoeT0vmQXKLHFsqS8ypDTiq7Z3CV1wRRJZZft8FCwFEp4VIAuNZci0VhKoRVd6gxaKv299YE3LANVvEmCrJSsMpLklKtUwkXqE+wyJUmNVxeRav7fNOz7QOSMllysG3Dx6nwLQv7xziwew5fbxefF3afZO9IDq7hGeXn95P9m8uliJmvvD6PJwF23eHOSNyd5c5Kf10n+DQAA//82zaErgwgAAA==\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5SRQXLzIAyF9zkFv9a/w7SrLsC9RC+gYDlWKoMHFCe+fQfTNjNdtSvQJ96T3uD+DSnotpCZdJb+4OphBOPZA0WogHDoD8a4mRRNmDAXUg9XHbsX2BvKKtS/kcjmbCsqPmEhM2UaPVh4OEScycPKdFtSVjAhRaWoHm486OQHWjlQtxf/DUdWRulKQCH/1GyE47vJJB44pAimru+BZzyTvXeNtbkjrrU8ckivq3+ucR7ioptQmYj063kjx1AK9M624O6Uhm0fi8vS5ZS0d/b7enAlZF70cwelu9oLrtgomJKDh3yNyjMdL7tta/W/ES5JtpFFyt+lM3L8obItibPtpz8CAAD//9U7Pon6AQAA\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"H4sIAAAAAAAA/8z9e3/bNrI4Dr8VitujEEewIqeX3aWMalPHad0mTjZ2ellV60OLkMSaAlQQsuNYel7788GVAAnJTrvne35/tLFAXAeDuWFmkNwWJKe3/Vt8tcqm199XlKxQoGyzGU9Af7WuFsl4/PkE3n+eztZkygtKEgw5JOAe9/GHFWW8QiSJP74nVzHYwikjuVcT3JtfEUkwuGeYrxmJ3jK6LCrcZ7ii5Q1OQJ8vMElsS3B/k7GII4JvoxPGKEvi44wQyqNZQfJoSfN1iaMncQ/34icxGPIFo7cR709pjlH8+s2L969OLs/eXFy+fPP+7EUM+RZsSf8a31XIGUNNZjzZQmJmggh0FgZJv8hRLFYVb6FYZAsM8brCUcVZMeXxkPRZwsFQzJ0hHwxqrIShN1e/4SnvV5i/ZZRTfrfCb2abzf3l5Ur8vrxMx5NtQSqekSmms+g5Y9ldt+v3hvu2OuLbzaYBcsoSMQcSFSTigPcXWfXmlrxldIUZv0sI6HYTPCYTxMdkArZANtsO7VbR1taBe74oqv6Ukoqz9ZRThvCWyWoQ91dmJYisyxIhxEd6mVOGM44TDtKEONV4/TcUe0zAVky4aO9OUhiIZVVVzIm71nqlHBJ0CBnK2Hy9xIRX/RKTOV8MyREbkl4PmIpUgqSuJ9av+7czaoCrP83KMuGQKqhRATU6AUONyngL+tlqVd4lAkLQ9uzCMxNzVRgdm8IYITEYnUXnd8srWna7eKz+6hccs4xTNoEEDcw4fMTVTDBI7wn+wNMWrCLc7ZKvEdaLF9NFN7TIowGA9zdZucYpFsOQXm8Cc0pw2sHb7XZr51mpfZe482kzHRazpEOAmYc6ApDCAhEza5ih8WTI2Z3ctWGiZiaQZbPhBwfR1wPQ7XYShoq+WF4CQF/McQgyRYhYXy4BbKcZny4ERCm6x4I4pHi7nRUkK8u7e9E/63Y7TDbudhOCir6aFuh29WQKYOsXs4QCRT5oX/a23epVZDVg1kmNaxiNJ5CjwZAftdCN93oAIyzOyTTjSZXUiMYnwMEZ23NZU8UAwLE8FlPUOYQrdK+pZqogByvMo3WFX+AVw9OM4/z8jkwXjBK6riTR/C4jeVmQuRhiivAWzh/dwqLUdOvg8Uz0VGF+USwxXXOXXisQ4q06yAt0Py1phfO0M4A+smJwv4Vq29yyYpas+o+am94tPBSz2cIpXa5KzLF7HLZbmCNJOPtFJf/1yUZ9XGKyXl5h5kBcb6Wz6huniaBvHSQaUkk1mlt1B+foHqf3LtSWAjwCLVUXdzvIhUVrXW/exwjDuXM8r5yvdwjDpRzyFnkU0VTmCVEnmQl8lCRMDEhGRK+wF0dyG6qITqdrxnAe5WtWkHm0JtX6qpqyYiV6Sn8lURT3SH+ZrZIQU4t477AXgyju4T6n55xJBNqC/m+0IEksm4M0jsFmI6ZgDgFTx02wWdYn2RKj+L03sNz1GAYZZsKgQ7EBZObQ0oRDDCDfJrI5gJcuT7HQwQJWiqVJPBUnTP68XGUMEy4ZmVdSuUXuNPUHQWvURwu+K4ywOg/cnnyHzbj1GpIPhhx1DiVRdSZpKLM7Lci8nxWkqDULWKDAtIfe8gd/bvlDQx0zdHAIK8RGTKNZOhiSIRAC1pLeYAkiAAnq9bKjqttl42yy2cgeillSJoLJXiUU1BgLEEJzAVsxR4zwZpPM+zhyJKTb0bEo0ugE0vG8jycAwDwpgGT8ek6FodJy7KGC5hoV40yyr5tkLQdfuxujJ7KWswD39STGk6EizfM+Hk796Tgc4DiZmnmBFCtGNgXbbTFLuCZkQv65FaRs60pS/SzPa6zgkkB2BKdECOH+yeu3F79Ybqt+ijWIrxJo5mSK86aRZljdFoLCaHrFwf00q3DNdFIixW0hrA3lF03h0mKWEI0nm01dv2MoH/EAZgilnI6Du6bcrZwAKOsFO73M8vytxD1Dx8gw0XMETRwcs8n2iuHsepjjWbYueVoDVysQa8LwlM5J8RHnEccZy+ktieIe78VRlueikEbnTq/9GGiqkgTQfrMJlaLxBGjFiQDoLsJgvr/L6lR4FFzJiaEDK5HG0IB+QXL84Y1ggsODww5CpNvl/WpVFlOcEHjYxKd6JjtH0xTFJzDVkHe7vIMQHpHRwSFCiDhDC5FKrhaD1CcXYzzxSoT8oTEVJQk3++jQHwDxNgE13zx2WXWf4Xw9xWEGZI8b9w8i12cv5WALxxNFiz/sk2x3furPKBvVfyYx+3Bu0JgJ9vaPf3gl8GQXW+aQQKYAL+RjhzkbBqkPatGv7shUYu+PQvJVFNgpvRAoTgTrahZmVyVW5UV1zulqpThcU15VJCAapEU/xxUvSCbmiBZDdZTkx8NUUh5wH6wjCFlLFFLUKqGIA2c7TjabuD3LuCAR7Xbp+MNEwSRDfPxhkoBhcE1ZoBD6M8tgJoinEPJxWeEoDJtBo5VAx/OkgBzohRk68onN5eYaYaRoSiX1eRx/mLSVXUmvt9Coza4JocYZORbXRUauoDsQgG7dQaVi5eGlPKEWRxT+9S+l/iWEa7etPEp7Gyd+QS1UyKYJBo0ejeiOPD3ikX2axkmz1x1ilcOLgr3ukMyc09kY5zIMTAcr+kE4Xu4ApNvQAEyt1eOYjc52wtDtrobVwx06356T/B2e3k3Ltnzqcwze4BgONj9OovRlgpBc7tExn680euVQn6Jtcgng+V4yDKlaTwGzECHOTK81YUdcylMVyswqy4SAUYFISrrdpEBq1yFDehchRfUGQNJBaNHtJmWSVMi3kREAPEGq21V0zINO/6ogeVIBAL1ilLUrZQAAmAkMIVxgaiV+SJwtxF8KC5mqoXGIwmw3xWoTD6ue2M3pdmsCEpItajgOH6ntS6GmRdpGqtNLzu7esHPMlYjHYT06FABs41bqNpTqZuK12T5E89pr3r9OSNAjV2oFZrU1gOxYerJ37QrngpQDpMmu1e9rNVRcdJaEZgPIyC1XcgqGzaoEdQYgnYUpmhzg3qy+oR741p7twwykJk/DT92regdMx0baDpha60rawGlPGtj+SeTetcPk0bsarqnkoQAHaLAAp6fGLQZnd/cOnbRLhtyxX4V38g9Z94ITMxBBzbsYsd+fNoyjHl5leSQWFgNpo+ahVRKzylr1eOR4owQ3TwmHOHBKoDgoiVD0xF+aGncOdzPp/azZQW5vKW127LA4Zc9qSQnb5ATAi33ak9aP6FWF2Y1A5c0m/sc/6p9xrdxdJ+C+tmy++xT7+phPkGtXN4z4VGCM7fLU1R5Hh9JsonoZ4fFgkrq2lUcpmVqSA9v0WuqRbx8wLF4W1fk0KzMmJJbaOujZBgNWwbKYcc/woyiQVJeH1ohS0TWbqq2GpE9X6hoG8aZ9IYAm+rAok4qck2kOaehIqRPtWdxO6ose8UnobqZA6m52XZsN32zISB4z3WWqfizAVheILtiIqfNGFU6q5YGUSgnIKdpsHk1aOyGdaNTYhIQakYCzu3On9NEEq9sNjdPtJjtVsuapB/b+yacQVrdrGHLcmfpqRH3J0FwmdijXoxeWBAlUm5ABqCWlhDetTjPKTrLposFGajO2xWh8m3D0POEA1KePW513KIToejXu8ZAsKXH5j1ScqNiXJpdj4viCBjhDR8STExTmWaVGMm0XsG5344vdar076qpYeZT7TxO/gUvgxHipIIBKm/GH5lTfI+5Yr7slGD0XartLEA3pGPLQhtQ0lyG8hYFyIkEWEKgSJvZGTrZp/qiJsLFQbxu2wueGTG02CUarvl7iZqP/ALCD2zyfUOOJEhXLVRnN6Jrkceia9qxxbRi4qu1X0wXO16W6CHzzGPNfSOe0Bh2t3nJI+3TNsbEBmp+nJMcfEINUWWPRANI9utsOY4Uao08oL2Z3Z/iDslI740GtXddDanVc/NnrQY1fj7FveGOpDVCd/xkrh9fpsTFz7OlVCjEvUAAxXWyzHjRoAJk9V0NyxLrdDte2CelYwrWRZ0wmYMitgYk7NpftFv720IBWEPD9oATsHKOVMShBt3sQPGbc2pC22rlKSnUzAPl2C1+3idTDYp1x9hg1fqfxP/5h/o63CYA/Ph68ePx6koDh0F7xaN8PKRRIFw4JAbvY2uqsgWG8QqCBE1A1di6KaG8QQcaFcOEAov5k/krAVgHsu4eWZJZzMVGTD15p1cadmhRd3K2wJkdvGb0pcpxHyqAe5RRXEaE8mlLG8JSXd5JMYUH7o5asXdMtl1VKjvwqNPt93g8uhevUHg41vX2/ix52HHpoJrGDXgqslLTyZdPC4gmbb8G+82Kl7JE9HgYjpJuMd1JS7ENGSq/h2Y0vrEz7XYLllr4SrFCXvdBl752y33TZrh5f2x5/FDUVx71JMBjFGYkKcpOVhdn7OI2Nd+MwiCu/0HW0MviiLjFvF5jhKIsqznC2jG6zKsIfVnjKcd6PRP1pRkybKCPRG4s60LBBqNwNYURZdCqO9FWJ+7HryvZRSe3+bcSbxm3Ey4SDhKrrtm92McKGTw3C3S4Ou8YozrjPMmn5V0OBURbesF2eN5iMw5iaVo9d5vlQB8ctVhUy8DvcQfGkGsK/e1qn7UUpY6GDFiYmBnxRoWhIZrvqR88Zju7oOiopvS7IPJpRFv3PMltd0AT8z8glJEIbTUTP/5SzAlu5p//cpfpaaK0YFWhsjPPif8/ZHPGQxitEoKC3bOSKmGIS32qJwXTvdQ60UAi//VTRC/K28KXnL8StKV0TLuQruwy22dBPFLeUF5C0LCF3CY6ZSfduRC45bK/XdgxTdG0nTu7Bdh/RfvJgLeD7NuEjF+E0T8a30SWktSsqU1q5FXhdHko7jh6SmCuwMe31JgDWbiTMUexNLwCA1DsZAEC2TV/Ii0M763+pWatLaYNNHr8Y4VQt5qVoKSiy9tqTrXZwwjAL2DrkPYihD0DtMRDT6KgkB1WROnh/33Kf3NeZPbjm6lGeipa35aO6qAXIHW6Wj+rF28+t+E9t63dyWyUwm4z0fwvSu4Xsfa0sLOEfWG9LOv9UwBtw/eaDy5VFfrKln4DbryVubzZxJf01nU/hXRDnLaBBGyFByBaCy1xhyc4dFrJr2yD1N442pXEWnDmzMjpzZXS6D65ay9hbSfqve36WGCp6rc4nM4oJRlQJmJAjKjWUMIF2KfLIRYs0qTGqSQDN+aDb9Md6w7chBp/UYpPZuc0Gg15sGL6rGdTk8wdj2XXnOkDSfSwh6EwqBP23b85PL05/PLk8PXt5enZ68QuAgb1wdpXVdh9p20p+qIErma7++q8Ey99A1frdtSxRx9ROIJaymzxABIBtmrSUFS5nzAEMKAa8lly+l0YroD3Tv98nutQhCdLhdDcwQjLOlBLpRk34nxVzPguKOXX/VtL57CFJx6yHdbsJ272e4aeLRHatDNL+IquM2JsrE/fVejbDDI0n4tBNeXGDpQD1J0xVqpejBihG1nh/po6Usuar4Y1nYsOYpCu3xTPj+aiNWwFpTaLSHxLI1PS1xax/WRCC2fn6SixfdOnP0HxtXceorvI8+ah2SRU/2lrm79MADrS7sJ5dt2sLNACNNWC//vK/o4kFFSnHLK+mqK41tXO5oahqOQcHkOsVfD0Y1W4eggMsBHUAIG1BoAWnhxa/Tb5xZOpfXNZbU92fm9gizfUyQGs3kfkh+QXq+AGMd2vR2vLknF3tkBk5ts+8GX1BdMiF8kF679TcG3ZB/LALsjPsgu+csXP7uNv8zQRJlOSGQ1aTRyaDRWrXsFbYx8N+gK2YCs/bbDB07tD1FCBHWNvZMKusk4iZoLpJ73YHHYS4PTEd7HpFdXAzhMP6UJu+9AJ3OnMbhzayG7AhXGjSceK5rfLgDgLIHsA3vmfreA0reZnlevI13PjEQVMGF/lLijkq7EdD9VP9Z2UsKU4CtxL+tTp2A4wp1qASrZxVmEt1DPkDXrSNUIdaXMM45IRko1b19bsBl+A/GoEgQ7xfye0HUvWmR2RIez3AxnQS9isN+qrtnJahcxr8A2NKqXcAtxwvB8M/PXPDFId+e90WDR7273pwUcEJ4+aEubVSQHFgzIQZGgzZER+yXg+QMZu4Vw+PmvI+7+O2F3Mj+qo+OAL922JL4Nqf74dIQA71OvIoRWPA8MX4I0bzcGuUWOeABoYBeKkDmVIfPKKJ47JsayWNHdDinYwg17d+sOVknlW1nbvtKyXV0xpKrlsNDjvi+xYJqjQHSZzfAkj/LNfziTMzEyJ7OV3Y2IiacosM5JGVzb+PoCH7upK1A/JR2Dy+31nT611eBZj6nyB97kBZFy0VQEfO354zR6qRTW4ow45kV+CkbZR3A5SswplhqbpLwS3DD4WfUkLwlEvsxI9UG50oUKf5kPQvGZ4dK7PxsLaNVViqLZAiV9Gsb2tYfcPMTIcypsX8SKRFQqmc1SdieEsAYd6S9yP2I/wcXQAoZ7UWWGV0qZFaLIikHHeEBsCtL5ctqhufZ6cB4geHkH99uLtBYGMKSqQDwWX9exhqDztssyHdLhOy32bDmq5Lteduo6FxaVj/aXlbkz5oRe+X2ZRTdidF7hoKA/GrsPrRQ1L4I47kHPNzNWICGp5Vbk91tV0ur3rew9r06UrhbsCm0iwcKV6vVWC6V6lJwiTsd43v7HHtAKkH9SGWtJsoayhoOjw2TENTxeY8mCnBFQBolIxR0u5cuvQin+G6FTBQDM8NTdU73hazBS20QrZgfE46lxKjeyM6pzrriEJUi0OmeABvWSHPaNoZbKGBuduqUaOe8J5KFmKmztpFwy109sKtUZf6/dWgdmrXhVuoJ+V81SVb2Fzxugbrdgun/09paYO3m5vaS99NH7ea7BMRd1qanHn5uG/C9/aM6sdVBHS5/w224Jxd7FE7XBMM7RffOldSGGpFVGwT4soPK+yrqcwxD81wTRPvjVfHKUklWPQPlSUBzhShSnFf/wUVZimrkhI6FjuFDns/f5njampUPDJ/jXmWZzw7kzahU/KbWt4FvcYkNpVUsYDdCzzTiYU6CPHRDCfurLk365hRymM7b27mvQVmzgGhx6QRCbip+ZOL4l69Hi2i5BjFl5erjGVLzDGrLi+duIMb7DvA73PrcvJLobFKxkTabrnSC3BMJl5SKY105ggrtxadt2edcACGXkYqJoWKMZ0goSVvt9uEAzcdl+MgDP/QXET37iU5BfV9ae1ywxUvGapcXATfJglGFMh4Ql0Pw3UyVguZQA7qnEZZX94AKtWlgJmX/UpB3KxBQKSRkizHYITHOZ6k2u6Y41lBsP2OYY5NDqvxZAtE1aGxTx8hMgTa2i8OiZlTwgQoxP+cfHaFYHQG54j006/zkjUiMh1TJ4DU1bj8E4MhdVZ/XFaIQqryASkVc4GT+DnJyruP+CVlJ4Qzad6mRGxRDIYvNawk5OcYxWuiAJDXfj4qTV+3q/6Fy3CtCpezbjf05SfKrjH7tqRXWXk+pSvc7YrKLlbsqAKvwmPNZcVuV/272czxZrPE8BajZn6/AYCXmuJatDjG2hp7iQ3pvsJ95dao3eiw9TEFlxjVv5R4Xh9OvW1zzB2cEjtTJa+zlWewlueG15lg6kgYcVJiTDgrcBV35J1ZXBUfsf7b62jMJgghr6ivm3a7ySVGDFgcu3QI/QdJ6B1Y2svMf1GCR7dN1wRw73jFSfov8XsLUlG/ry/B7A3y62LK6EVWXSexV8Sz6jqGbnTUCfYTaKg0bG1/0ICPKO92i+osO5PZP9Rf3On5HGsr0W7PAsWSo2aSQ/05Hsc9LJNNnWOTQwpGMejFk9g48yBkOovjnuquT28wY0WeYyJ23vnc+KJqk0Yd8dtKA3UWq3pAXtfmw6YRP/6VWJcHlSNlxFOlbauOBpA4MLrAnuXg8nJG2W3GciF3XF6iCwz3sUABYkGmE3UPbHu9xvtzyQlMapDduDF0DESl5nwQusAjnIBUhTa8w+gGJ5oRxwHn83suWHOKt1sAT1XlNzKFTVbGAL5VJee4nMUAPte/rouVLjmT7FtpPzF8owioOuHwBUZvMPytJqqnZ9+fHF+8eRcD+HqX1APuQyLGHHPUcnFpOAC8ETI0QuLflufL2bosFQgok0VpdEaNey2TLpVxTx6GXtyp/WG4FlJ+fMxs91kfvfR2CQYyyO4ndaxT87eRxFglRGyVrEHhuhInZbTNxXfv3vx0efqyTpgqgIz7Z+9fvZKAfi1+NeW/htAXZ+SulvLaOPszTn7DQGCEXP53QXMA3sJXMgLqPUbfYfgSB5BfrduJcCyLqVYVnGR68CNG91v4TUPDMhxDyFwYyNhFLij5R0ubuHa31rvcWTG6isHWrjVVpxKuKywDZNKPeAvg7xj9qAAG/4nR01/J0/kSfotR/Ot68OyvX8bwpz0iuRRGfcT73biv1545cru0W4iJDHLsBIgMnYjOS4anlOWV2r5sNWT9CvPkRwz12fwRwxlJvxNi1apKX2GtRUgpcF3hM3ybdg63AKp2v9l2vz2ynbNCE0dKBLwTgq5lqosW8a+Fw8GQHZkkhfIiRvYxZpM6U0AorkMf0e9xEhtx6ulxmVXKG6par1aUcZzHOuS0I3QT7Wxfh2hsNh1iDo3T4XtiPOntCZf9KL+Zay0qykawCNjP2yWvsLx3EmCUPKbbJTYpk5Dwh3vgoV3SvhINk7UcXkBnN0wLNIAZWg+Lo8z0U5h+KpSNi8nQ0w5O8WZTIXSKR3SDDlPv23P17Tke0S46+Nz/+FZ9fKs+fpmukff5HR5VfYVI1zipwJYrmVwj1xpSlekspVtj85TMel3hkw9FxQsy11n7hhyNTSsBAL+O7eer7cR200nIZvMNVkff2dsnYg+eRAz/vi6YwA/sEGt5vSRoERM7RmVOLTWe2W+xCaZXodgYwjD0pq/ti4Ag9+cwvES/WOIwoKgzgMQuVRUGzoNF5cJZ4rlQTKZvDW+ycUWL7AZHYzPjTT2xjTOdjRluElEWjfW6J8bNkGCVx0uATU/SpL26l0SCC4pBDHWgmmKw7TbRB1HSuP5yXfLCpgAT7Dmh8nsmqUfWn5EOQi/NqfwXTqhJaCFpFIUZ0hhhD6OiUuNJTZrEXF4aqvUKb8Ewk2fQw0OKiINBygOn8uZUdbtVf0aa8xmaqRRgu00YDEf4NyUPj/4rYj8AIWouJ4BVfoqGrULRWShTLsPMCwWvLX5uBbkmWBpK+EU3A8+62WaTlIjKcTgs4ADUKJaUiOjIKoTem2UrNvkt7sXHBZuuy4xFOV5hkmMyvYslrEqE0CsM7nVr9B7rzJmkr7YFrhDpzwicISL3Ai7QKymlzyxFXLgUMUeDYX5kPg5zQ8lu0GycT+Aduunr3YNz9Kx7N2JyQTeK8hiz03Ch74/NBziHDM4FKO5GNP0dw8Pu3Uhw3fTHkIwkgLPdmkWVaDqS9pIKrTx7SeXaSxYAgHTlW4MWtaZYbr09qv0MdU4ULwWDALwMdq5lUgwAFKrN/AIvV9I89jbjC9QqUdaQNVFecBxAyX3UQtB7mTRb/3olrwW2CYYMeqjoCiLQT4yimBNvDqrlKjw+wxMdmy+HlwUA8v4SV1U2x+gHLNWpni2BflIIKLu2q6OwNZRxHmrGvbcVKhNy72csM8dNJy9wExIQR22T6HMupZktgJrIGpVAKrG+8tqMWf+XqwUKMq2fOFgWHyJJDa2sUUUZySOG5/KA2VJfpf+hLUy6kiOWWat/FRITwv3pImPPeTKQ+p7+cQgQ+haPsFZbk2cg1Ync0bnMClvM/ASbWmtHvKGtRwdfR3HNxUL5IRWSOIe6UG8VyMDehpJagDozZDEZUm3H68Vp3GtbGbLR9+dvzvqquJjdJRlIz7HMhrZlKL6Pe9Tbl21sYoX9DVRukL2EjOIk7pFeDOI0Fg3GcY/14kkq810zvCqzKU7+iaFOdF1vyPe45S6izqnaKaAYy2cmR7/jRIprOfEz61XzmUys5fiU4l1q68BRHj4LqK4FUReH0XJdyZANoT3hPJoxuoxkKKo2sUc6W1Ds2EFEj9bPsKEUaklWmfwFU68VRNCKN1AkZmRIDTEXAwlIdZno7m9dG+UlzYftCBS9X2lkSXM0tpr3xObwjT7Din/Cv3W5ouuaArvWK8lgQ2Z/7JrYjV1fG9d9VZwBuSfS7d4wsNasnxtVNcpEI7UTUhyrbfqxc0mgcQQqSX4wzI5M38OsluTZOAtI8rXxBSHUvO0ZFRv0t7aEXxtkdrT5oi34x/vqP0vpTl2gMnrAz1jKTlauM4UM2F3kW0XFla2OB60IY9w/Wa7LjOMcDSYoNj9iKD6dZTIc4XCCYvWnLqYEo2eikBJddL7Icnr7gi7R5xMU21+xoOP3WwCJ8h9thSrMxEGJv+of9j/Xl2fL7DfKTJH06+VJ3I/BeDDRFQoSrnA4MayWTxeBCtpz8Zmhvf0YbBNdDUDGUUzmL/DVen6sjzKksuwNK+YFyUrt7V3IQvnjFZ3PMXOuzDLuAZfxifNiiP+Nut/WobN0uOfa6uCwcXGlHdKcqydDNUu+03xmXRsqWmKk/w3J4YuM5CVuBnz7KQJnBck9UCmFsP6owSrDA8PIWPDJZrOWquSQJd7sYHzy7t2bd7G8q+92W1/fvDv99vTs+atIV1OiWriT6PjN2cXJzxexDCfxLtSdeQanOJI7rP6ftpcm9xhoJ45Wxx50wtY2VCm1pduthLg5BLKEt2yiU27tuhcLHK0YrjCZ4kiIDIuiiiS1iJYZu65qNkVZlFXRFS7IPOILHAneYz/1YwBXHN1v4Uz+fyGxMOctlnvj5COwLCoX7DTn2gYKYM7Vnd4u3GtlVhu65joCdaiKZ5kz6XTUfF/g2cXdCquv51hb+Ch5gSvO6J1fnKtC5Ut/xZMxnoQywTCxY1NcVYZTihES9e7SOeYyw0m3eyU0vn2tjfVAxqV6SzEmwiU3Oo1ySDL+4+8o5WZs5DVcZFUy5SAMg7b47c5KqcLboIKtAdNySsmqCjN+RvkLAzmTbNgB5UCFfXlw3zcVIQS9MRUTMSP7FJG71GmJM2aGqzv2ilsQ0F8bisxe+4GSAF+07ccDExsVAIJ5rgn9omMnJAykzeyLLtHid+HvnbZFuNKnNd8E7LMJQzLcuKkLsG6XuWLBAkuVpCFYbjb6wFqvk0y7BRdutVMib62TDMhUzPM6xtZFVSxFDDvxjpi457l+l7OMY1nPoNezLul2b4yznUk7peRJXm/5L9Iq1XjIowXwUDiDxcBAjLWhc4usirKS4Sy/i64wJpFtJLi+n1+ufeR3OhFDhhIsLYsAWMBLLIRUP+jG1J68lu/umc2ABbJbT0c4pTCrvYKoaGE11c1mwYcuxKkMSKX+cACqmGamwCLJQwHaAAmYmtJILFvduBWgF0eY5FW0XkXFckUZF8yh4BUuZ32ly4TPm3o2oI0xhaBtzCgowM6zr3qvwD3XbeXBuRKV9adgCrwdFJl71KOfY+njXoDt1oxnASoJtvN77zA+6b7iSfb46tsgXpkqAbnplltkGuHUM5VDEqgvq0KCVhwyw5aLWXLLnQwHc0NquG97h8bwTnYa3q1RnQXuEn9uXhxsw1b7UFu3giOgCoogrZjSyAZ0jzbnjLGlbzbyPHRUXWedFAxDoxF8m1DXrkhdu6IdFIgRDc0SOCuEQQ07CdHNpjOQGVoccztrE3Zl7GHdrj2wTLdoHcbXxQecK3vVQfv2m2tlzlgFwwNR34pB/8BYvCdVHzFWQlEtiqw47AwAMGc3tJE8MQNu20efQwqGXHp4yTo2pjxQsyl4a0bSdjPgxtiKZnw/eXP9CBSbJnWEoulkJZm+/jnj0PzJa5MKgG0rnKrV7do/mlUSgvQ30O0qEiQtxY7AE8zR0ajREHlUDg6btU/+4cMtxNMDikun4/rHdrsBjyPn+0h6KEjjZ9s9tVFsZAtPdE3DPEMwKbctaOUmldTLhs0GTGa18NbOfrcI2O+M56u2cUVFFS2LqhJMLiNRY4BIupoVXD1oNaxpQzh6Ftci9ZInFoMcE9mS70ohomTPFW/Jnp1DAO+t57LxGYDyQKVkNJ5Y92U7yhU3L93ukb1bPjC6Vap1A9vbLX/gmU1b85J7CLYvdWHtyfioNnUEgkCFD7Wu+3y1KoupdB2NTsVOZWXxEbMYwJOdmqaXsFfJ9auVaFzZuF3bU/1kSk4J9n6YTMAyDFL93cj1y+3LyBiKv5UjfFjvYmvizL968FWGeoZmOdJE5Ho/6ikPoPNW9NYKcGbNDecR71vAccL7PmaTBAwvuXx6UJscKdgaD1YZgtB+nlpmHeqrOy83pAJrECVSr5aHwqYEILWe52zNYKutH+ceRpzmsUNCLmrzRBz3rnkC6v85DoCOEUNZSfszRpfHi4wd0xwnf/9r73XGF/1ZSSlLnn353/IXy0hOlwnQlrV39TTelhmfUbZsYOVpqMaLGMC39YdstfqGUl5xlq1eFRXHRDZ9vttsF8yFT+ce3dcWL1HeTLzdv80YCVYWH1RtjyqfcftqrUNa360JL5Y4mtLlqigxM14OJc1ynMcKRG8+bRW6L6U8nd+RaSO5jZiCmI2/Hq/V8+qPNSP587KsPc3/4OCNXj5hMiXO2HE29QNSdtV52bAftqweajqnebOWOD0vuD/Eb43fr/3fNR786HBn49pJ5f7L1Uaabanc4L5bZz96UeQykWaW51HBI06jf5xpLVn6gzte/k5aTT5+zyfyMk8M+x2Hrzh8Lw3wtnoMX34akmnqaDt42ZR37Tb9yO1pgB8fM4j1A33JVatvHjCAKhOy76V4aawHxg56qQBb4NpJ0afiOEC58ZhNho3myuWmb3dMiGWQ1mrQp0LJM//bQWpzV4ebV67UCqXQ4xbsGkX6Z3SMwC+3wc2S9ztPmrAy2/Q7/5PBvUb74ZD1nY1g/QqX2i5r/4TMhyXiDdiKLuTdAOHnuk0l/T2ahZD1C7Ja80p6yos/IOvTNddF+q+9UYsBD2jo5pNT921aC9dhO7qOfszQgSXfJq85gP9skIZvG79/CgT4XuH+LZ9pgHaSDt5sOsl3MlaAZVOhVyevOPqO9/GNfIV5AIDv68F9X4B1WcrD/wNHPzlp9Nw6DbFaeXG8MsFJytApbUZpsPm/+BZ+v7v374Rckt04/UC+oye+hZ/tRsCW7blzqBXVPRhJ+peXhWYkgRxEblTNsvCfw8GNxBd7wlMDQaKNx1dDZjB5zZWFbDDiy5AH3n7no8Q8u22WNXK7Dj+Zb/V4m6t16yVp9XJ06FwbSfEnxqnzijYHqr84Twt0u0m2c7QHB3PzoG7dgAD/E0j/DOhCi5EAI38KVCTQryqD7M9AhbWAIUuAflIy+HCTg9/KLdBKEa6Z4NI8Z1ABWJnkJfCXh/RH6YOOSXZV4leUzM95Nr2+EATN2mJVLrL6Ne9FVr3FJC/I3EaWVValdD5mrY9Fdc7N47naJPReLEDGYuPb6DOedA7tBZnt/WS54neBCue7Wur8YXX5rnC70E2LumieUjIr5mumdPLnRPndaQ/xSjbu/1bFYCj/Uhc84s+3Qh+sbxUvicxZM0cm6F2+oqKRR+Z4RG4YH5Q/bvlM/Hu+wlP7Zpiq6/zdn1F2nTTrA6C6uMgquYvXBZk/ti8BhZ2NgcR7+bn00OSTZhpuCgDU8hOwzb229yRb4jTO1C7EcKX8AgtcpfdFpTdH9CazNVBySm7oNRbLcNlZ2DeaCJYCcb+wbRLrfWsuYhhRj2iYnoO9wmpPv0ldKdDrd1kVnKxgdQv1TXQAINGJXOOlCfOMEaL96SIjczxS92Xts0n7tjrkYlCQxsus3YE0IQcPMO3b+gCoGVvHmcCsrdjt+NeoBfA+W5M3a14VOdb7FmQd+gxL3p9QQXU7h1vX5FRUp8TZ+DavljEFXoiskN9jD13Ulak6vDu7U3c0jfGSwJ3kiYkP4jS6krdShmyIFjC6WnOhISpzQscd+4zuHf6TR9dpuHfPoNO8LGZr0nIo8Byi1Wlka/O11VzgRkBId8xtqg9YIGqjlU+EqKyilc8kqZEFaRT3GMQQE/gzhz9zL9yBmsHUU+v1caL9qeCEpfrWvLVka/LtOmO5e/W+d5269q7l+ji8M7GRovcKbi37089cKBtSuyDINUhwk2ZvgBC2PETmMgodcJvkSD7Hqx5oNY16PYhbvFQdKxX9acCnMl3pVgcHcMdYuvvHnGJsWbQ7Xj0iduWBrWP4J3L5jTWYuvJNwrrhoVyekSKcgRyjKGv0d3AAJYQl6CmBGdnvSfi/KfDsFXaCgk5IyNlhig+6+jUtdMGTsbf6w7gfatUgEI26MrHcrn0I3HVcKtGkfvpd7YFJ2aMPcyVFDH8LLvMi/4my6/oVeSFeX2XTa5WsVhbdCjFOL1DSpEqmKBLn2NNjeENUCnCcpjQV73BZC4y54/rEBYCL/DtfDJHIb5ctExr5oBG8FXrd7j3g2Bn9/MGxf+E72FwC4Afc6Le5Zbh/ydbk2OzQ6ewdznLlZLdtPeRZkCnDWYX1gXyHf1/jiu9KYdZGnB46bOLIIIBf/qA5ftSg9mFxt6cDO6BbejRos3f9PcqEtin1EFzxKrrCJb2NPmJGHduyimAKQe3BxViCtQtc7v44yeK9LrvdjodLIRLZcCMOzHb33aFHWhMAfCSaUZYMlYdLfbKNIbm+hHe+regqAUN5C2EUd97n6q/TXAitOSX4+CqpTxHYuifqcAtqHx9tCZ5jrhctCEBlkgc7xKbxuz8rSo5Z4JK7g/vrVZ5xfHy12Tg/Eg42m8SbN3bn3Tm0froOQrddSd157tr4JqEbBUtrNaGSAWHttdyrEL7UJNqFRfUWs4LmxTTF/TzjWb8ugTkusztTLn9AafssKHlF1X15qi3EThH8sGCmEc/YHPPtFqTjScMpM88NyrV9aa1PFKTo4FDmuv160O0mFO2w7rgbyx61q5GzVx2E6BZAnDC7U5C1UUg+Pg6aXEsHLiscTTG0vaYUGlRJSZNW3i4waZ71+sVvYs5wc4dblOmJmFvEdZXoIyVYqDgmlj4S40SrzPqmqBlFZvZCXamnkoB+dFpF8UdlXnmaFxV/KqZwYAbo/1bF+ip29ESfKWcn9RLgHhq4C/0/mVs0nrkuSG58IqsdOoZEQSHprB+QOC+z2iGkjhMoiVjqBf1Jpv/SaRGDV1zzouKYOV4lDQe09iDaLZo3wLMm+zsLdqW9VpvX805fZfncXaArUrW7My7wzX27wELuKcqC3+3Wv7ye1A2eynvT6u55WdY9FjhECZWz0YzRZRLoXfo06ZRMra7fUcpP1Lutn97zNb5r9ysQzgHBKblgeEeioOb1zAAIXAp2YB+VUa9wc8re2iyK7XlbhC5l8trkU66rHVTec+f/8CodFV7v6zYBAE7lS/UrgmTGh9qvpizp7et1yYtViVVyS0cjXzhbspIdTNX7tHnwBBGV+U8RStEX4o4Wf7MrtcN4YnI7WO+ZNIp7XL+HtnAzc7v3Xo1tNN0U6I6oNGWdYrMprH+iRPcZEWKAzHMEcCLzeU8znnBg/rJZjWid0Kgz2AJHosnQJ7QbdtzNLGYJFbyEkjq8Qf0MzbLt5ijfs51mJLrCESXlXSTYy0oDrR9ph1IZ9bVi+Kag60pW4TRSl6RRppL0E9yPwZASpEKA5wTYVG/i9zuu0uqprPb7Yn2k6pH8aO6lLRxYlWZQ2qnZto5VbXsV2L0KuP2eUbu2CH8oKl51Yl3ZhxdWsw0EFdcd3BZ8EWVRXsxmWGijjSuNhQyZw0TDKe9Hb0uhxpiIkqjg0axgFe+7mctkbIvF8DvnuLS2eURJai+553tUe2N40+FhRqNfyjt7RyfXPRtfsvYX6eYYIjVXxg9N+QG0XT5sNAy0Ul9MKF3FCKGEID7ifSX+aC9VlWotI2liRJVYZvxTX1MieAy+jX7hyX3oai1dqCcLCzS2x+gXXp8jup0MXXNn861QjoL4V0DlfZIyiy0KI3FfAfNC3phnS7wF8tpPd8EBFEfcw7DSHAiBfVkQVeVf6iKASbHNop4aLUq+YfS2wkx7X0QFmZZrIbi5zwtbr/CABfGWCIFYIwIk6pXHx5geqb1A2PeKaubdT2BlUYAeb6HqTkeR2SRpgemEA9B0ek0AzFzX2pbnqPXJ0Ut7Qa2jZEIAJNs6pe4lTwowKppupsR4cj3uPsW/iJFwJFuQFjpjy3+iN8kntkkmH2z0WXjj9O0MQhvu4G8MeW73Eu4vOIAULUlyL1QiJxm6xOhj7bqZjOkEBNwoE9x053VjoMLUQr5O2VxaewMDfmTYn/qVynmF+5d2oNpF0D5WB3Z838OaeD1z6ahg8zZ1xAyUn0CfzJ3JBhmuOb3Kx7FuOaWk4mwt1gF6T+Tb8na8Fc7t7ZJNLZbjaZkxHMW1Q6RtENfulaIyi7Io9qYWR0vMF9RlS7OCYMncZTA4rnD/CRjuWlrCdXyOIR/1S5DuBtZx1W2dpslv6h52JKh2nkCIzZbH8H6OeSAbps/1thCT9VI9pJsKsdPwav0EAYAPRDdb8+KeKFIZUW9o9O5IUiFz+KDTT2Ptj4HO6/jnHQz7Qbmqzc4HjwK2bfAAtG29R4Dbu6lb7ku8ysGI9xnO11OcLAnEIC0EWZI6lKAAVztlH2hzfdn0RrV9/6N7vWFyWXDYkJaMKy3+MMUyx4tmyIjZlr4L6jvlmcoQtV0V/JxnfF2hQhddNf32HVnrpsC3zk+2JqQg84ti6lyoYDKjbIrP6Bm+PZauBfWV2GXlX8d4jqV1xzV5qMcKdbuwIRUSYO2rzj0XE5lu05Cwsj4vptf6ikH7Zak3rH3hwazEdFPfUHZMUcjyHf5sLxahM6t9NzDSMdBOQr784rrbAbgOTFoypOGjRuB2XYE7nj90u2Mnu9nsg0/wa1F/rRet7ockIDoD9VD61jie1pMPXI+Fpt+cux2l23VHPPyk/ZEWeDGppjoI7hvPhUDSfD4EDP0r5MYVh8lbBzkaDHk7oQ7v9YBMbVyn0+ETDZxdD85C/egmRXhsfO8PDq0ucpZQMEoYwurGBJoqXx8GcsR7PUizh24GQNqqTL0KUKcZY93uoQzLNOFTeDyYuBmnRqIg/TkhIPkpwZABsE0quFYPiweYjHy0KOFohWHzVJAhQcH3zYPcZKsFU/+xCAxLDFrPaeHgc1pbYMN5uWMvCMrNexTVOpTOoeNS+QgEFev3+U23UVYJOYrhSEhpFS/KUl0vLhgldF1FhaPURJrQ9yMrYrkiXEGkDeZ/PBnsf7QMpwU2lZdHyRT9GAwJ8sJcX/MRTvfzrD1hFSFmop8D8UtNxmbijv27TgfnM1cprv+TCz2dmD02Ob7FwdtsSB0yQcGw2KHM9i/XpKRZbqedFIZQZahhr6sIdN8vibJut1FjTUDIwp8U/VLff/WJTGqmzc0wMwyyOQcomKeJZHED62LjNlbYfTc7nOMbXNKV6FhsJe5Hx1lZRsrK8ZbR/DXNcQIiTnWZts3RfK1FKdEoBrBopOYs3Gs4z9/DiraOrBGwfNWgeIdnsj8xfZ3XkOHpmlXFDS7v4jo24VLUUuEPoM7548s0A1fueUgC5njKtWTiyLMBucVA/RG9Thd4en1GnW7drLBW8HmcX2VLTmyaQBq5i5ry3fdcKPyNi1TOs+nixwLfhpTfobtQeSA5gFw3uqDPV6t3eGae+PKVnL3d3pLE6VkGr+gmLxld6m6b6rp3AtoqX72SBPcXtOLiT72LSiZsCqf2AdoA5XjL4Xhi7eW7JOuAVsWb0Q3+IhrEpL2MGnLeMgzE6tnDpjrsJG1oX8qpLfxUXfBRCpzoWt6pPqDAqSkoceAxKnN9wNEPvEkj/qK2NG4qe7eeZQrXz7SDIfn64LDbxd6z7KLaJfHjx47Drndj3D+VOYEywmX2SftLZZt8kVWL46xSSSjND5tr8kNjkJPARaxH+RHewvNGo4sHbp7zgvG7muoxXK1LRwebarXLdUW0r2AHZJhlwyLmuyipzqWnSBMTldvEw221e0W7OQm6MzYbk7zVVGny4YtUv7nW+du35vpsBGxKdmR9epqDV3S5+5VU21rUajXlVJojdrou2MbqAHuNx8c4AaHX9L2mqlaTqO55pcgfuH5SqQnwCgeomMU9B0mdnTDQr6lm7bjj22cIGOGEgNRJm6NpMgNbQaK3loBr7D/0ENtfhX4xXlXIKu5/HjsND0ziVnmN1qg3aHgjEcqL2d0bYuwaTeqrD55ycA5wywrzF3LyzYbmQDeZa5jIm2Gct9e9cl9HVXf/1w0S844gk+nlbcYXbxmeFR/S2D4NJArP1zNZ2CdzXRpv4ekeQ1md1FWZ9l3L2KyYI77ZvCPhBBLZHkpQJ3molYE3XDm3iZa1gpHasuck1xcMrTPof94RUw4ZqhJsEvj+JQbwGYAUsfFgAgvExrXCXadVlLGMcY5n2brkMYAkiaeM5DFI6O6rDDwuJtvdn98K2iYfqthdh9cgCt+jNKUTB2iB5bfXzRAX66aIjw/F8uOzuW4et6BApQOehYKo7YHCRYh+CwN7rLergsLGfYCkvYdBycwFkSdNvHXd6jq71XLBi6InMs38E6FsPZEJzZ7UV6UqadDzxmE7a/x+0/j9Yq/xub7qqNNDG5OyEiXOaC6t0N2uF2z6GxnJYNPjRVGqx6r1ATGZbuXzC/LEOCZkcz7/c/cn7sT7j79MecQErJR8qlf9KTOxjf9DU9F5uz9lAvLf/8jwDEsHkimuPmUGdav/yCSMl4N02fqkifgtH3fzA38je9Jt1HFt3svc8oOf5EA+GKtDVdH9FlKhYrLias3N72mZVZX5UfG70n4QJ0ucPil804ZkzyHdkzHBHExvDdhE6NY9W+0V2wfl2k9tM7ykN7jdn+Pr7vRolCUMhgeHHXWVj9tUwWmhdSkOD0Fj5IJUmHE5MsPk+cxXCAI+Ow9NRjCQhDSrAT0F88YqXCdj2juE6nVjGHYHM2uSOW5NzhcLKA+m0h8ssLBv8Iyy3e4QOxei3hY1js+KAIM04XZGPDQjaSBxdnnXPhA4kA+TeBP+fY3Zbidb+fV5WSYYjAcT417bav+8LAMIVL+848r56pBxd34hM0mDJ3W7iSjudpm1NJm+pNee9W2FPDw/dd4+cZLNOTw46+YcWz2YvltzDhNK7jELfVz2k0h3hrsDFNx5cSnaPEA7XZhyVsznWEWymUvpgA9tuds7gIB7onxsEe52Sd/EDMjMejLDxQsC4GtSZ48ym/Oju4zXxHf8trW+k7VeE+X77gg83qNKr7yT+ZGodx4+Euf1AtLtMi/HTuOpc6M4SzFX/z0cmpzqTN0VApghqv8cFrOkkNc43a7yJQMmqr3+tNn4nw7VS25JoTzRYaYzrNrv8hUvDl8RkMqXEDs48P6ll7uyLt1s2GbT4YEGPNiAg81GvzAt5db3DzmA3io3IuS803Hr3X35zyjhRBld1mRXLdwvqp9Up8pFQ4+QysAN+y3U1DuQWKu5Lx8jSRsnZOnHaXRUHQ6qyrhjE1DKPgrqrUX10qmy4xg7vTT1jo9emtxviHyrO2mmS91sOn6y2dfZCnS7AkdlVu36GHzTzJDUkacy9A4rDiT519HWv+82P4aAoJ9srUKs5yNpqd+tVGEeynxbx+DDfzb9+e3NLvz2IUw19k5zq1aQa5y/M296WBHnck12fjJocsq/w1nufikCJRdZUbolWZ7LZL5Vs6r90GwhxIBWbVnYrClFhqxsVTblzfpFjgkv+J22W7Um739utpZRXd/cvSQIbzb/DJ4DzRVOOV62GbPMF2hMawp0Q42bfMgR718KegoMsWj1+maFWTukqX61xu3YvvnjgggyNNBPJAz5ZkMsUe+QzUaKYvrwnwoJ7uh7kqgUKSOeEpih70lSyN+wQoVXVZJ5IekBdnAACSJqKe+kRJfbHPV2jdpnorAUSPYCWK+n3EDpZpNQ61K7RtkBgyWqDpgYaN1BZb3sKRoMp0fr4dQkXVyh6RHVaD+i4+kkFf9DAzhDq950WB6hWbc7O1p3u4n8sOodgi0dN+YyQeXBervNOghVQsTR2XCC+/LWno8Hd90/SoHdN33txoLneY7zRwzlnbvASLKf3cO8Fjv3iGHsYQ0MIfvYPYRGj0cM4iJxYBzd0e6RTr2D/dDJbBOJwJh+l4Gh82I280ayLxLKrCACu2FHsoVAehzxT8TZnXwkisqwmOiJzeP6pB+9IeWdeopPvbVZcCXpVtI9JitLeovzRpS9vJtPMJDqWOB5rIB7cSv5rehih2I9tHcGmOsnerS/qE+ZMqSEvyZ39xmWzaZqDnqFBsPqyKkyrHo9YLL1WNqcVFDIsNXEPHqCim73BCdFX1c5zQVFSzIn4d4NZsXs7h1Wmq50T5ETrwCAsmnB8dKaS+TR8rdf1AcgtR0ui2opvR5MP2LRAwALVCjsUQ8GEkGVPMYeAosBQOBdR57gMdHPzEdhEV6/UNJJqBXdgRTEh4AnVAvdQtR2N5UKLK9BSiB+HDTDoMSQQuKBUohyPAxHrOHoAVH10AQiJL2ecVvRWEP8tBKcrck0k2/SGF+IslRPhdq085W8iXqcm7yqu1NZNVSiTX+VMme/WaLZKHfpXONTgCp9mhv+ZePmsvbC18syiSvMm2j2zTnKEhzkX0FRBg+xSgMlRBmfqZlyr8sgn3I60XzKZ88I+/KHpN8BcXOnpIl3sS8xMn9gOMjN5CSHGzbF1sdKrJ8urO6XU7fNeB99gnZlOhs6eIsQwiOb+0xK8WlCxToFJNzZy6ddDDlIsH5xCwX0C9dN0fsgTRzS0DVKTmTcjqAKfA+BVTYlC1dpXpUXgky/9BiYS0OlcWfT+KTno8JU/8CUmKZ3/rQcDFcfBIf/Sd39yyqw8Y5Mm3ruzFH3H1jo0KdadIRRaDUUGhxgIPXPQUemd/TLbCiHjJgX56NSzs6txRri3NJm6qPoJMCRdMPp+Z0+NYm7TomZGPGtRzobMDDejE3QmKcNw1RcHAibNdQrdciUTnrdpvVea1vi0JBQS3UK61SlvG4Tqu7SEdvILfSE5eCAbbpSj97+FhKEVbfNfEkuQrXSIfyRvbKEaGhyyUsU1WuD1GCM0UB9QsdGAWJMU+YDiBrPfjoKEGqWUm9Mi/c+JXDyu3gHgrTPg6Vr+3M+Wkz/s+MZsvRQisnd3TeYKgoemlGILxvf+Z0HCbemuw+FFBKYOYxcsSTV+pp1TNAHiBmyhjhsoIW2YWGBELIGhsGuxSp0b3WNNrOzR6hhYMO30Q8Wmj56r+RT1LBBWUkLJuoY7Mkns5dStj11C+Ird97RDB7MfceSW+mBWAruH8QGPImFJzHwJP6e8JTYXQvgs8b3sLW0KdOJ4XHapMk+JtviUVPGMxgcJOa45avsb8WuPP67OLpFoZaV1kOiJpXcgUZS/m0zAx+FXWI3CjCTgMYilu3TRMkM0qRR2u4sZLZ9iH/hIEXbaenxEEHIdnV06g5pGu1hi6PdIrpBjMcyTEXptgmAPwXT9si5mrQ9Ruk2k29vrCz2Ed3RKTxtrGHib9Zrfn+xXjWrNIqaW+/U3FFcS01O4etQzYCYsYX/eigz2aJh4edWVQrneGpRP4sEoidzDha1KiY7xOY4WXhgH2TAkBlusUB8wm69ukKrN3eodr6ukE+GVIiJM3UjU5Ohtc6/WK9AMUsSs8zNhh8h4qEUkMYe4hh76jduydDPY9VywgkmlzDLrVnCi/VqB1dYeDxBQqPJFrjHFCQYYWvb9PH64QFkWWYrczcfwo7VmgdXVMNGw3uZrcxTsWSzSdSF/7+0n6L4aB5fBVCmyGtdDO7YU7935y2mEbEPewesuns2w07ds5rV86/5uWb34pPOl8cl+X2U0UyGtu80mtmsrBI0xUf8aWYtqbW1PMNFX3UmPu+q+fuG1NgQC4bWTI+YQXWmozAHrgvFEbGRvglFZMwmALIe71F5dfzZf+7quHnjvdl88/BlsneX/AvRR+CXh+glc+SK19nKWFyyVevydrXCROsPgavi1+0W0/Cd6zR81/rpt8aPvgv+FL/e/5TB11n8HpPvp2H+4++a9f590mXzH7jUfL1zmIdvNRVbf8xd4HTvtZzu5//8+vT/wd1m6IJR/b/tJaNpxh+/alxmK3XRqFxlGteM6joLW9e2/+Nbxwba25DsHUTLhre5l3HMZBYm/Wt8J7kBF13eXeHnQpUzEc5EuTP7fdcuEO5r+rx/Ocf8DTuWtFopaS8p+wHfJQxiMCTqIaHa2/YNey57TYh8HxJIa5k6b91uov/yDIIhUug8U0kMgrEhQ765C7Ba6VVwq+2VDjGvh1AqppYGmAASgA0Lmv4JWcPTjHlOZtD/qXaGuToJc9a49SOiApbKaVPh0jTBm/8fsusqfcxcGAasU/62odbdLq7jdOXy6hg/Y0biZt2ueUpttqwhxK4HN8reS7hIKfTMZrJh83HUPiBmPDujVg2QNkYNDKqk8QasdhyCNrh8VJMP1wNPGLbftERsJtQ+pNxYivWpgdSeUCPkdbuJWTUFUIZv6aUzIak7OjFxkVNlEywk7fuZOHK5P0OVsboAsAh6WCr70HODf0nRyjnxife3zpVoUyjztg02r3YbXPxTr3MD7NnpwrLnpu+pB5QH74f3XA8H+2tLoJ8gfH6q3Nm6hW2iYwPRT3DCoT9hsNkk+5fUaOCjkUH7to3Xx7Ld1g4PAkELfggq1pq6x6wfbBecZhtajUk6+zl6zA7b6e3kEDiglLQm146XF7vYlLhGVhRMOEi1riFTo+NAOgriJtEYk4lMH6uVtp8DmROESIJ9W5/DPF3TYLN4pwkwZPJ7lLluh2nP5bpbiNkDfsr169qOT31Tq7UPPkgqUF/89J3HtVXCAClA14HzAV98/IF7PNrah22SYwzXlUmomrpbJSMXdsbGqo6jU+2R90KmtK5khmu65lEWqbimyAaN1kGzNsexfMQtx6sqHY8xFGM8V/+c4smk6YXazB5hXkr14aryR4TiB6z1QSVideBrTX1744BN2u5I9yM0CaUmCEUC9+InMqfW3QqL30nCEQYyUmazsfEXMnhYrIvMTyVcJOjwDM3qpNH5KUljRim3wfkhlVxu8Vg+UE4mUmqWp4j/ZxHw/9Oo9wO+k8f+/wj1/gTicYNy/M+iXGzIJ2FIYsNnZAKZeoIOsxpBoH6WjrOEMAALhm6IxH8YTynDMayTnp86Sc/jNbkm9JbEW2i/z4mG24944hSvTbFb+JzbwgmAGbNPPryi06zEp7n70EPFnDzcrI5yWTvl1CkvmWs+3GxiTA7en8dSUJ2yxvsVqz0Hw0iYOonBCzq1bpMEM/F7vTQhmk6lfrFcqdBfleFNodZ3F69fmRZJXGWk4MVHWeFA9hYDp+tvaH5nw4dbA/avaH6nDf3BNh4m+k3VZHS9JF7wZWlSCPsVlR5Tx6M+dm6NAcRUY5lEzO0vOOltsLgvX/kU0ENPjqqb+ddH84jKrFooVhKAPNRnNDfG/gTEXx89nX999FRUfwI74X5lHOm5Tgmo/dz2V0ri6mYeg1F4/u2Jrr4+klHiXx8Vy3lUsSmKj542Sj5ElMjn3FFWYsaTQ/D0afz1EwXvOeanu0G+c576uuIRi4mK5TwG3a57gWCfb+10buWLL/0Xb16/zViFWZ3MzglTVKat0FwvbcN0Z5VTF3nAznpoZwc/f/cudKWwo6ofZY/iI4GfXx8pxPn66Kn+QxLRo6fyYyyzDWKEyZTm+P27U0GuG4BQt4Dq0ElN+PWr7zhf6WeqhrzPcLWipJKvOqA41+uNIe/TFSZJ/O3JRQzjPONZyvEH/lScy+F0IYDH0ZrPDv4G4x6G8t30fiWNYtKJUVsDbP+SNNQPNrhB5cREIBZlDiBpXbrt3r0/DDQFEOn42UQlIM5thV8yutSZpjCM7dJj4C2kER3vLYSH9+Lh5XmYt4uN76VtHC9XZcaxlSNU9g/C44JEfJS4JEFeTz5IODR7cXiJQZXXNMf6XFecFavjdcXp8qx6zjmrdhDUMNFuJqNq9bYjvg47+TCEeG0zZw0HR2RIDg7sU3zSaSMhSsodxh+WJalSUh3GHZkneCD+sWkSYlIdpjHYbAz5fm5GEeKjGZ4i7Oz6kA4B7ROaq/OEkKT+J69OXp+cXVyevXlxshtUFECqY7fPi6uyIHMtKc0YevrvZJQmo3TB+aoabZZZUXK6mfHVhuNyMytKDNLN+N/d9OnoL5P/TkbpWPyx+QyAp/MCLkQH8ggno7RYZnP869NklF4tV5t5Mdv8tsLzzW+r+WZF5htezGabW3y1AhshEFFZcylqLFdfbOh8Lj4uwSZb54X5+PmGzjP5ja7WFQDDq6zCX30Bx9nBx8HB33u/Pp300H9/9rSoRafcEYUSjMxJA6CvYktmTAJe/VgwMMJpohLNmhSztxkjSfzT83dnp2ffppGWW4TAuSZVNsPR+3evIhlGE8nzHyUVxpEAYPr06bw/pU/J/GmFp2tW8Lu/fKgqEAMYq7Zp3HOjlm+Yo75Bhu63kojUKJDVGalgDIB8nVzH4HdUmP2wLgJsrIPrJ6gzcNKwonvJb1O8rdOnsrv7otvtmDD+hCDaV1ADJplBQr33t82LULwve9saHuTIoXfMTf8NhU46nkCGBkPWTgHOej1AxsxNAc4m+uK9AYgCZQlRUahm9SqN9LAuUnBcI/3Snb0EKaOCRGuw7i+y6s0tsfe+JZABoaWAFdhqaHFB7TW0uA+tqtvVg8rnX4oaWlxBq/BfK9fQwg1oKW+BOYNLhm5YEmcMZ/CKwSkt4YLBYjmHt1csBvBKfZ/Scs7oegXzHOYclgVcQS6lYZ5DPqOUQ5nvD2c55KLdrWrHVlBK2JcM3bHklsErBuCx/LFk8I4lVwzK8fOc4aqCGePFtMQwq4ocw6uSTq9/X1OO4TSTCXnhFBOOGcxxCXPMs6KsYF5kJZ3DvGAwL25gXkJ5e43FP6aZmCFmcHEIF8/g4nO4+AIuvoSLr6CYsfigVieWTiq4zAoCl9kKLjFZQ5LdQFrCFcOwUkFcsFovlxm7g9JcANelOBRqfXIxMLu6YjCbMkrullCSEngFr/ICXuUUXhVzCepCLIvmWC1mRiBewhklHBYS/mIi11c5LLMrXKrZZOwaroopF4v7HbL11R2UAIYVrLLlClbLrCyhfjO2WmUECjp8jcU/lMxhtb6C1XolHz+F0gsHcg7X8CZjUFJDsY5LBuAHtXtX2fRaAIbkarYLhmdQ8BjpplBSMs9xNYUrWgngVmwKP5QFuU5FvRjAE9VLxaYVFkhwLvf9A4MnGk4KSlNcVdf4DmZlMScwKznM1pyuyuwOZh+KCl7Np7SkDF5RJrZqistyleV5Qeby72qVTeXfZVZVUHrfQNVgSstK/k9AYkqXq2zKoZAUmPpAWV7BPONYwkPzfoVH9FZqOnCWTbHGkQoucDFfcLgo8hwTCYwyI3O4EDPAsKjEHgnoVFO6wvKvFaMreF0Qs4uyvvjfOpsLAFKBYnmRweWa4xwSKiFM6C3LVlAIqALr5EQYLqEMhqElhozeVvJ/YmFMvvulxqymjJaCtcJqkYnfxUf1v0qjA5vKKVQ8E1hTY3Gh4svkO8CQF7yU+EEqIWVBudvrCov13ahdUslTbtTKb4ucLwTqXOzS6bWtSzMxnJ/TJeaLgsxtGtGr9czJfefJSbqRSXG1U0pyxBQ+BIJV7JVURlpQyZh5czQRelCrzcXJz24DqRvortWlSbpzbQPoicwcuT/r6Fkx3fv9k9ViFSZ5PdehlwYLT6+PS3p1hRmu60DuylvKxio4MRleMZxdb/lDrWsdH3i3uFfrWf83WpAkjltibQ3QoPefWOZZtsR9Tl/RW8yOswqrZD7HrMkduYnOFuPJTFDxkbHX2CIOLJcV0osnLlM0GNIjZpg9NdkaCiEIC2GZApgJ5p0tMaxQ1p7UeWtSlWXyWs4ZfmDjatLtJmuUs2QNBOVTBQSt4RolxAiABABHkNrx+rcUHvucFcsEgC3QcIZRDJorj6MYZvAJip/AUzEwfBI/0U4xu3Fy2+jj6/jhJt4O10j4Kfsb2txut7MMFifNTX8a2PUmML6Om/eO8qy2b7Fsk1PWvqsMnoWAj4CKQBRMhWGjp76lVaGNzV15hF+8OX4vz7B6RebN2eXxm7OL56dnJy8uv/kFmJP+QLWWSfplVpQ4jzg1aoEQ/JdldIWn2bpSr0lgNXP5vINZTSpUhT5dc6X1Ok+W6iTFDD0d/7p+8bfB4ODX9YtvXr6ciJ/H6ufLly8nT+fwHUNPk/G/f/3Lwf8v2nQm4Om8VntOPQtwn+FVmU1x8rT7dA7jbrZcDWNgS68ZbCN/3P1L3EsOB8+++O9EbeAxzfFzngzAwZdfPvv7V6Dnlx+Cgy+/+vzZAPS++vLLz78CvXgYb+tB3u0cpNF7o93TIznlkrszfvq1LJyLwlrdeOss2jVEYMe850JlP52PL05ev331/OIklq/6mNO0TTAY4b7uvn4z9rky4b/D85MPqyT+dzI+gP1f4yf/ddn5S5QdfHx+8K/Bwd8nvY1SsJcZZ8WHjeXtm2qalXjDKJc/rvHtZoVZtRJy7g0GySj9efPL5vMcjEQHbH61WVQlyNQvvMIZL8j8AIySUVoWBGdswzIhj4ODufgDEy5qTrNyuhFUGYBff03GB4ODv/f/C0Z/UfOb9H79FYDPYhjPYwDPhDK/ZuWvSTL+N5j0wK/gs6fwTTDLPR7j/tmbsxM0mKBY/KFeCJAWncMJisUfquj84pdXJ/LFAPmXLjx+d/r2An0uSuWfqvj9u1foiwmK37/Tjd+dnL95/+745FJ8+XKCYrfAvjzwwhN+nCeuf2NNz+9KQBtSdPjXvz/rMpsHVcYgJPozOjj8698/77INgbhfkEIH2xwcws4ApKIuqVHwNfODKBPZs+4JqMdCnV6O5BvbbrekJ/ute/yRNWKXBCJWYz5xMgM+XOXVw1XeP1zl5c4qAqAfGbqvMD9WfgfiROn3h6GyGr6jVL7t4ZeeLK9wnuO8/cW+GdL+ZJ7ofIdn5gO9wYwVOX6rE+g2y8O9CSXlja5R2VLBeZ6T/P1K6CRefe91G/eLTlHvFunnn17glT/5F06+X/NFv2tzI0iKLlrL0V8UTJGAyi9/h0mOWb1MmTj/rRQS/7nGrLD1Hfz/hjWzCMQnH1ZC3S+oTuWv3PZO+XdZ9Q3G5FisF+eS26VRXVm+x6mcZPIoE02igstHVqeqRT8yLibKNJaaDOH9SOOHU05Eeez64dEeiqNTHlUYL6uoLK4VK70p8G3rKXA7fmVut1U+JDEXpahEi+wG62dDBZjqSX6XVWLiXncFiTK9tki9kSQXTOl1NIoBDAXm1BJB7f33O5Neh5BsE+pl6PxdHyI8ZnyCOMTjQvzbL+lcPQItdMCEOy3+yRq5AbX0IZDthXkkVO/Rcy60XS5EEiGAZPVDqRJ6UvBQyQ2/9ckk/Im1M5P+qzZIop9YI+6IbzYJR9pP/DLu/cRk+A4U/+pwJAC5HOsHhuLPPlsTFWuRx/B7WYBlYFA93GfOQu+LPP2BQZVkOsU62zTEZJqtqnUp741TIQM7v6G0PeO++GcrB/6FoUHd/8/OAdD3d0knqemzjHbDfVrmUqGsxlxuRkHmkjj3yETm5q31adrqr+OMIUn7ns4Q80k9p83zube5UIoOzdw3m84rksi8I1qvsvWrMZmoiwglv37Dko/m7WmXFonBJUVXoX+w6MUCXaj5g8FBB9UjAvdtfUIbRgChSj/ryuia/qzM5jKEWU8V/Q1AoYKrd5QIzwqCmaJdm41Rdeu+GVUHps6DhYek2yUyTgIQ0+lXX0iv+2CnpNUpdWBdX/iKdXz++ZdffvHF5wIrxOQNi1OrGGleW+fMlxQfA/jRPk4miLjt3DEk9xml2lgees6Mu/AsqCepqtnLwfXfNmG34LMv9DzVximZ1HaVBbtqNtdv8ftNKw356rYQi3g2OPz8i78OvvprlytogPtpVuHoMNW9K+A4U+kzyaa08jaUtZ+Z2j/uqH2BP3AHFGvqpoatM5l3Osnnz/761d+6zaWoqTneMG4Hie1hs3lc8ymtaeD9FhI0UDczBqJCoAvlXFcnuEowfCYvasaDCcwQHR9Ohq0XRYtRwsfFBGWQbELy9eHREf6vz59tkwKAlMmaWwDv5a0Vzg3D57B+xiBl0Pl6d5pXKXGAuqINSa5pAbHZ+8w6m2npRglFCdHrA2JxDJHx4QSkCZUgwgCycMZdFsi4K6gl73bDMXkMnmF4rwQGHoiKu5d7llLI6TUmKVP//oDv0n+xhIHt1tnOGW0kDdFYp0iFFUJGAyRoHdPosNmI35Y01MWsr/X7miIY0Uyolt3uAxV8BiYUBN4/k6m9Fanxp7fzaGlhL1XsdkElK/8JZ9ceO79xUHlBA+w84QgHXmL8lm0BME/QIAwX1OPw9X0frV8JB/efK3VHPpXL9JKds5ZI6qKIbJlVGipCSZBWTgDgXHU3gA4ltnfuepR68Dl1nyiHWc0wKkSG1RFiMmGkthi6xL2aDA8Pu2vDp65ER2vIdTew6qG1SkEvH/1zTtGS+q+imwEzhIdZt9tZ0yQDQ5ChTK/bSWZpiuAaZaIaLNG63t6eOyKcep8Oh9MjVLoJbytnMdPJcNUniqebxBByH65oUsGVnSyc9tDKXVYxSzrGl0x1PEOaZ60YNS65Z5odCuFjJlNTqgS8M2PZFdO6FXCZjacTO5oDtKsG0IpZ8jfLUBRE6/krJwlbuY6my5BmTmIiAtNIt2uPJzdb+YXoWYtBLyX/Tg6/ahR1u3K6WQ0Z2UOrSpu5eTKA0wFImz0efvXXv/71mRxarbPGg3a3ngTTv8SOglzBNRoM10f20nzd64E7mlTjdQ3r4WENgA635EdIgN2uPCXEHbB36P3iLuK1Nu+2sXka2+35HmpRgVjRIPP8HpnYMXnlYYSBzHtfRFSA1KvyeZp5zk/NLgZpYQzRSua/pOjpv9Nk/O900gNp0u+Bz57WNPCYasfWOJWGvfFgUpvMlRvIJTVEcSzf+eLjZxNzIzaOY4gdk8iHhuA7gKE0rRuEhRAuN6W29dpOThpQxRt0qB9cntL65YZ7u0vpwSF0JDbo8ghV4uoKojZd89Wa25+KYWJl0LClcuclxqfSoiDfB3aK5PfXvtAxgA0pJOv7BS05xKsgSlyxJXOeYoI+GUsJrFEzZWaJVTqeQPe0pgO9WvlFo396T1TwMRTnQP2Vcc50oXFkS4vRDU0KJUNDe8CtUckvlrK/X+TydvVptb4qi6npQY+XlWWjxLUA0c3mW7aFK29UaS6Sf0kvVr0YAyEludcodd7ghnANSziFKzhT2L4Y2ofqsm43yWQ66ulmk0zRt0zdaOYC+QiANyhvbukdyt19mvs15J4uVTzQlco2X3S7yRIlC1QlxwK+Rma8QgshM8I1Wm8244nlj7dSgFGy5lofJQAv0WB4eWR+Dy8NBzxGVbIeX07g5wB+QMei4xN0PH42gedqwGM5yDMAL9C5+HqNzsXBfmdy3Z6aoElNvg6/7H7QFOyL9BSduPTmMJX//C19h062t+PLCdLi5wdIqvRC4dc1JPT/z96bcLdtQwuDf0Vm+1jiE6JItrOUKqpx4qRJm8Rpti56+jKMBFlsaFAFITuOpf8+Bxc7SclOm/e+N3Pm9DSmsC8XwN0ve56zfJ7T2QuVYnTADOvvFa5UXMmnm01BCpi/nM1Lb+6FmTusjJp/0Zj/EamSQs5/Hw1fwogkVp32tR5BeiTnTCVowVCO5NyXvFy+MEdBXZwvSJKRTI6jKRG1ERHlKjIV/5CrxRXyCpVd6xsSQkNyWYBNNha9bLoqAE74jBDyCzfta+vOECmW5YKEPYUlQ1AZwxjSa7JeB5Z2wAlCZr2gOzGKplH3D97tpj/zjU/EwVh+Bo+m2t6b6hg8yRzhZRwnYk0MjoHwV7yNvVuY6qtZrMlXuo/PGxfwqX/hXtZvWe7fsqW7ZS/CS/ZTmVwge9G+DO7ZM3UIPugb9oW7Xm9+rS7V2m+5Wef/5Fqd/vtr9U1IPYIVuZ45zg26XGkDgxMO4ZkC/EgCvmVA7OXoipMSULNRVlOuVsm47LEKpSbzYXmmNK8jExrD0rPDVRyHyNYKc61RwEmmRyXpK9NDDsizivLnUNKC9IfFDzrVHJ3CXDVTUpka40JeuEPZsvBUlvFUHv2pvH2n8mZo0Qv96DHfnHJrf1j+wHoaoloURWzeuJzgjLwCTNZhrjhZkrxnbzmcTEneUxcgGk27URp1l+kSKbVRrWC1InToYmdKfNBkxXGirWNXRGv4SALN0rEqEFhSrdcc+71maEh7s7xalhWEYxibUSvsupwQJS6e4qVbj1dlzfWqvSq5s+9ya+bB41NvJSFiq/vtAm0Z7yMePxjnTcID9G8CrgKuNHB672JZY/3t+QKROmEgz0Lw6OGKZCNzTLTKBLdfSYZzlObDSj8E1ciPww1ncWjId3uiVNF8tArhkOESV5ijdNXQqmfgfHsDfrozOGBQMqRLGvNyPHnbNR+VENWwyKoKDCfT0pAqNmkDlGC9/cO2dTOAvn19TrgSoEsSyZrpShpawq1dqKFdfMAv9ApBiIYuyfSVkBO7nFXbcoLHitfybYUgQDlKjXtXm2iXsD67+7tm14SJjOQ7YCLHJUrLocdDqqiwrEHZdIY2SZP2P9g3sDrK6+x6O2p9Oe314VC+VHwzhULgo5L8yZN3FOEX8PUXRfgEvn4VnnHmcUMI1GHkI5WY81VuXniw9VyWCcevaSIQsgSY4lgKpccZsGj/ck+NwdTBEQx5R3tvnrw6+e3908fvX5y8ef/45O2LY+3eBKKt/AEeeEGl3+etWFMi6FPCj7daCdM4z6Benvbe6wCd4BRQ1ZbvjYEyw2w1l0Sm74ajUmHKL/Tfk9Jw/lVwaPAfMqNzG/O2enD5C70cZ8Bcqhyn7r0tMNbBRZsxx1eg9ddaljyXK1khSWUQ8rIcaV7pagOqqTD8utl5HCdcO3XeI0lJthRDPWeaHsdJKBt26ycneQYKCy44aulVRT/eGmwSjtZrZd5OCCmDlrlqI6/k8420iK8IpmvNKIJea0vrNstSLXcG+30NfVsmaRi/xmAZK6guDOyqWhscLH4xIS/LRtJzxfK9ZmgWZTg0sDhi6TYwtEYWf9AkYFU9L31/qNeIsO4M9tN6sAUnITDxhlQbXNfpp55IXgxDURikJXCGmcSCUE34Vc/H+nNgix7coKj53Je1tN586jAqR0dyhHPSH+Y/8GHe7aJynE+IrptPnCdRepEoNEFHFxZ4lYzVcZngEiGkgnLqkJ2iJyEiuPkH/f3Df76QIkG1Zdy1hDdcvn+2dF+ybEKvllHQScrrF2q/f3g/ZaoxlS3HF5S4czdlRDdhvUjADaZII0JYS4BTtl4PDgb9e/ZuX69bAp7KQ35iHO+t14kpS1RdhN2bM3pZpp6G2zv/WBG6k1s9dO6FxXotfrQQAJrF9tetAcLihz7yrFeNs66xsFc9bxPtKxT9cal0bT7zXlMPSm7is1L+61EgT2pSQDGqStCz3yKNSmlNlH0pu9y34rlQsgX+wmyGp/gvc9TK+iF7gYUMsrMDzIwj9ma5t3bM4kcbHm1EFfObySHa4OR9uBit2p7eMq/arYGsWC6ToNpAaQZ99tEgT32sxqX2rqe/wywVPLXcGZTeCOkMJmBD09eC0leWnCYCVw6RA8VdhiFChSQKSSm/NYVIclw5IZIx+K9IhiuAomM6185VCMdVLTb9DcJWqy6bbmGVA7bxBNtYglDQmUV0ctaB6FJyz64cD85ySOCnGPucsxs4RL7BkPXKbB+zHaSAQcLwdaXmgEVtwH7psfiywYtdMXF94pY3FfCZVgTtVItyVcw6H2jH4E2aQ1KS81JZMYQbr41nQZzZnzSF9IaP5DEYMmL1powuqxzgej2eYKAp8WeIjfqMAyHbMw7BPK/RWUDFOJL0iazSrwn1ccROb51TXsmrGzPRm6uQPfSi82uZZPDxC8iOKxVg/LlA+Nfdx85RsdsOXNl7L1eKCKy/XtE5YfKHXRvC5U9aHNM50YU8CbREFXqLsoIFgppKm/IYlClLbtozyyNb+/IjWJRTYAZv980soYTJlVXQKUep3ZPByLfqUtwgcvyNrgjtYmnX+H4vtwzu64whuCx3h9h3m9ublqwSfCUH/2WHd9b04+tm94rOTYFEQutuD8C0XtWWAc/nYpP85dPgP9UZaKD+YhLhOfqtvEFAdAX51N8J61lxlomMMJPlozmeveQNfIrrm+Y6uHWdfiXopP8DoDMYg0KYnm4diXUcQPxREP8Ia62aPRHHdIgEAV1HTIlhsdtXaKTno2IkNObGdNCyfxN3oD7cAEScqxD6I+kPqfEVIsi70ttqTNFQIrHOmAC0GnZEhwh8tYR9julEuVTztNR/8dQJOqyXCZFNF2/Kdz5m/Yoqr18I2xDnyofjDfZUTfOaq6ZtZb5w8RumI1tIzraiiVivrzahm16lg5JwzCSZ0NKXNR9p4CaOs8m0D60QsIfleh04B/1bQHTzHBgZvwpkOGnWBV+OOTbWK63DzOzzKqmeLByvKtPie7pnTQG2+g9UdQOrAdmLsokIgGQvCiI844xQZz6V6WOVExuDRglid6o2aW/BCScCxbFagD1C+HqdcJJbJYCylQ70DvPb0oSpb7PVyOEEaNfuexCMe08phWmt9iurpj64a31GG2wX+FlyXw2Fq0a3vQDoVXBrKeuNSDtzTA5jpllRsmvN4zLY1GNFlR9iZgj0Q9+du73mhoj3nLRYVuDEkKSbTdIPLMjhBt+AU/ktJHOJ8BNJ4PIf+6N8zG8NJkouWiKcXXdp1IJy1YLPfAEwypr/CBRx1XoFG84rVXCCHLwKnJHki4AVjTmpJvgxgBrSngjBZbgHqQCIJc62rXIGjIlMr3UJa13atc4aS6knsD3c3+753jAsUONBEnHcfJPCSBRUhA6Rt7Zlhjuyj5GJCBHE6PmzrFk8/SITlCnRVjyuFYc7rwFpLYaNSfkC/I1rnlALKa0buQxwi765y/UfFfmfAsj+Y9Kehmg+yNGueXWBStNFv0q39mBuD+20R5LB/v3YG4C6ZL/stT/L+MfHJX8YRgFBV8xf52tA0gcONYiY3LrTqAMaNjW344ZF4jUAskpDyWuGwpD2PtDTHNSV4CNRMrjPvNc0KA0GbiQY4NFBaTvNkjraF5qe+qMzHQR2qdtXRuIY163NmhxeG6QlOG++ysN6nbRnAOC3Z6kHsu5qfStBqU7uyP+hd9zO3USnqF8AcdyerusnW3LNZQpNqwvdvxB3g+FjXp4dqctmy1TUtfQsAOgtr8bWvsy7XO/J8+PbmFfz8X2zyCtlaJtXnazgNJtddlTTytNFy+sbzIS2j6qOLbSPT7XxpaNSqnHFpRyeWNDO0XJZ5Io99IrO3QgbjwFtBIcL7aLAb7RKUlHddjHXPJpjC2uNGxnmO8VgU2JdwjCv8b+aLNEttE79kbQMypDgUQ79bdeGo0Hn7styQA0mi8Ejyw24TLriKzq/MS+ubSj/hh8nNskR87bxj+Y2/u5t4+87eEH6XPpIhOYDbXGy2x5j1srPBIi62nU25Al3XgIcl9rrFu/tuR/gOdRTdbEZmoAwhnB9LZqngSEcMM4a4RBpHsrzfJtXZWFsyBMN3tosze2WYyfUQWjE7WfKw03dgPoJC1VN3tWb9ixCQV+lv3/Yr1d61qhk+e6Na+RpUdDTrOjAI5d25DXSsf7DOvOSw68OXPadqOsb4Yu8dtpYnjidJAVXLL8GN51R2b+gfogBz2NXXUNzK6Zv2mlR6mwPDNnuPkntuVLiBvV4TsLmQ41UBjrdIKd2etNhBV/9lGK+hZkiD74cc6srmbYKbzQUHbHpouTb2F+1Yfu6sjcbr5A3SWv3n3ZEZK11Kwt7TLZrumQNR9SafwAkRq1TZwHfH7IfRGBitGtaYzZpxRXkPjQD6vv9hM16Im7aBBZfzk2R9vgmfEXesHxg98WwGJcTzFvxp8aj59lbDYWztRJGWZgROhaTxgi98TONE9i80MSM1dFvD9v7p5uim4DuW7ZEaRQ3+Jitx15rH2vxRkszPxXlh6z4141V1Nwr5ulvNFm/j5xq5u4GrexzC+fWu5VKAiYlOeHjwUQrqOoA0H7HTppKcY4ZLjUJUNvisFjZHOADpSYNrjGesnnZGOC2KYHSb6N0faRWYRhkEa1AaLO39QQquM2etq2M0thVpVp7tAVQneN0Xn409/9zKhblrNGrPGlaAYq27XfL5dkYILy/Lf1nLD+rhTVuvOnGLsQUlhQCKztFyU5dfBg624saqA/Pm5q79KJTumR41cutr7p1IAI4rNLwBL0Uw31aaua0/vmhLEUleLa00oTKShQlIcDtN9wUz+BgUl6BRomfQ2fWX6uR5MFVh9svSaVxiVmgMOppB4peXY0UaS/dzRzw020DmjrtTj4ZHva/v2t0rtdrp0E25uCCc8y1AqhSjwP66CY4daACvROdrilK903MRxu3+zBmI74mg3Q/lkX4mhyCIiCs3VU70qxVtblCnm8kW1Xo525+HGix1uDm68hVrSRfM6ZeKQpju6zXjufzTWitaxg0lpTfweB/s6AddtpRE+9ArGEj3oKV81UQUDcCl1+G6FduvEzbPUvbeyejj7e90PogKE9Xr6nAxuqoAeUSXZHUj1Kl9AqMy4lPD+WhznkJNFMex/keIS9LYweT++qWwxZ9zGy9Bv+rSY7W6yTT92mOMJfvRZLLE6OPzJY7otUHjTldiYomeEOGXqNpx5zbJAjnOfmT+15CNghnkPaJIVzB1yOG8Aq+XjCEC/g6YghP4euEIbzMjXXFPNfWFe5mXuR162Wj8j6GBc6stdoUBELWEUaSjadgBluMl+P+xGq531cWidOGWe4SaBptLFi30FWJykjXmcnO9SBWdhALFVNAO7NVxrcDZ2G7MHa40J6zw12NF56m3AzmvCaDuwf3D/XU5eQLPPfI0Fl9ZSq3Nspce0qKurn2khS+ufY8LHH5dFYNV+t1sgIGbbVeJ4pVm5OPNMnVJbogyzLJ8GualOi/wB9BmwXs1zF/nTbMX+e++euybv5q3CA0vAxUDfvXytm/rqz9q7L5Nyam+k0ptYVFrmwoFpsvNDs9zwPm0gf103O8k7e4SHOeslYSMIaIeQJj1dBFnpgknAH0gKt0M3yrvm4TQI/d87kTMI8u4JdpT3vnMnYWP96gYVBXqVmAIifuVghJzUA0QEeMBiqX1AIbgxENnMFJr1p9qKY8/0CTM3+Ynnpn6cw4Ud2KUwRWnHxC8t6K2SaVy8bcxXr0XATl/9S080Owtsn9wff7/mJyD/u6iXWL23Fvjxg2W2F2wFlx1MfbUHcpa+Yced2cgzfMOXjy0NxfZZtJRz0fez9bTDuuKe7/bDXzyLSZR45wRfrD6occXERl42pCvLqVY3jxuqlHZk09di8p2HvoRh429sDaf1jLD2f0AOYfngee/B/shER3eIuF0nX70Vbmmj25QZUb7IujTW6+N4xeJNy3XuK+9VIG1kvgHygnvlfoh8GC5vPEUhFKn2MLrXHfOoGzW6XsKjVWOLRe4qAVF6wuI9yZTGaEkGkO1MpesifWa89hU2CzihAWcTzw2mRAAhIDR8jzLUaH1VBh4qhmk5nn1iwqTz7lSQV3k97DzGbaHGcXDCWqPG1IdKodHh91w6vc8xBZ7fB2pYoXeQoPQV2cgLY2Ykr49lNT2+mfZWOqy1zZpM5toT9KWcLBojI+TdjIjSPwLuGSa54okDZgtWjZMzncVYvApFivk4JcGaon/SAHuUIbXGkJjFdpQgqEC0shbTaMrAADAaXXSh4So3iIDz0oUab0ipExJbnSXDA8AyD6NDTi97kd2HSPkPf5el0S+Xc0TXU9Y23R3oDvjO9THnDzVLwT3uLsLAByF4mFEzrkAQLD0RA5nbZh06nEo7zhV05hIIH8KjPyq/rzXx/KfpwFzmsz57xW2Q2brRgz51iBK0e7E1LiO/uH+/e9znOSr9dXG21w/5b1VuyCZ8vAQzALXfzyCRrm9eZD+mUCN+VjllS4BPe8+557Xstb2dEDKXHueY3KAw09TwcxFsgno62UEHPSt1R0i88O5asj9/0f7mVxnOt1FXH8MQcvAjYFS4wO9wlJck+lMYZoJGWX5J5/OjTM5J2YmU2S8Jp5vuwyr+wQZb06DSG7Tzh5k4OPBoE5Qtg5a/TdvuRtDksCJ3rD8geyzY+evyK+hLWcDM20WWMhmFqI2pTbvKnkdRcV2ts/eHdxOIIVi8r35jMYIHm++pX4a9A/vH/n3l05HAhlcGewD46s8x47BUmRpZVykSC83//+3uAOMNPqJbTr+AThw8H3hwf9Q9vmvbv3wzbledMN3j+4f/9u/37QIGiO2NYMR0YVsEyVJHBH/SqvM0DNoofk4tC5EwYvwUMnBw/UZYeeSYGvfuu2m/luE9V5IBz2/e69Qf/+/buHcVLffGTg9s7B3fv3+t8P9u25iJNcBSvuzfNCUP50FgsE7mlqqTHEZCiR3M3jnIvLBOG9ZOAaKrs++PzgC8rj2I4tOGrBeDyt4nXj/G2ARXa4P7h3b/9+XLsy4MJQS9F04OodiaFr4YuWqGXm9cPiOcoJqKnH9XcIHiilbeVcO2mfcPk8seskQt6fpSI1bJTkpewn96hK7zvYCayjUWNQENdHtuVVsi8+vI1uqYSHXEKnW9zkht1Q98qhIetxWlGRlA53zIgubx8dXEk8U7kdzXy3oxq7ycarCZ7W/OcVpjpwtQ0xMiU6AnPNnR5hspP+ho8LR7CT6aaKYwmuIp9fnuj4FFXiH/OXAeruooOKYf4DYWCybz2UOqjKJxBgLOQTjXkvn02cUx15chQ770i9DhVC2HtqsgZ2CjhCPbHlzpHImT698kR7v7TDE0BQlG+uRL9gN2whjhMFf90BzoPXT9lD5F3iJ3p+abOaX9qCrHYbayivv4Xv9VfzYIvxdILnJC+TJRrO43iuvLO8zJMl7uNlG4yCI2fFZVxtN7XI58nC8zi8aPQ9I4vxdDJ8mScz3MezrT1trl/Wvdqy1lfOhW+1wHhkUV4LRAw13OE6EuZ6T/n9JrG1q1KdeG8Wt2RSSLJf44LYeKzy9a3aryi3GC9C/N/zUsfj+Ex7bqs5eZa70+754MS25j2+lkPgu5EoyaCOiXKwqagJAhS71XiErckErpcFjMvJ5r+FCb7/dZjgV5sGF7zvc8GvNnU2uPC54H3HBechF/x+m6vdkAXuvCxeLTlVy9efbG7E9z7O6+4Wfe9rpPRVrlhPdtJTfSDNhvHgTkFvLu91Xz0K7HeunJ5hyn0fXAHfXZ9qOqK+V7ooQl3jas3zPtRKMfRxTvo4I31ckb58VHGhNL+n6s9SvrVz+c9CJcxIfzhzSkUzc9WdEzFWz9W5O4lkhs81BkEKfB6QeqTE5z4Pm+T4PAgtQKY4W5Nz9Q7glfysu/Q9N8+bGsMlsQnDyzoXhBSjYhuHJNVCbG3uqPyOXQbsFdJo0Fub87a3F0Z8g+cXcNYneVLgcyycUWGX2PUyz4V8Ls9r4ga8N43jg/jcIl8Lci7JoP39Q5OIrpbrdbIke328dQVIuAJbyyGviWB5ttcAwD8loCgM7A8zrKEkqUGKcG6jV5xu36Txnzw5d/IZYPGgCTlPk/l6nczD6QVju+nctk1uW88In8ax117DVQc5h80tRkkRGEMaoC4aDAA/r+Ui3XkI4rgVDrc2dBPYRKk3pHMP4fixjwpyjt/lyTkCJ93nyAtbXMTxjBBSeKRGEbA+4LyekcLQKWdxnJwFa+SvGD5rn0Pr1BCekqQgZyiO3+VJgUZFcK2khQl1f6XdyJk3V1OJaYaNRZ36XeHmwqQr6zARELpUNMPjsfX6J16Pjsch0XcC7FvgKrrBMMTHzLmBCUM5AdZoHj7jGFldDOpXjps+o9KF95C887XHTRgtdQrjWFmPEhqEavB8VdVwKeEgsMkjl0+CcZfT5shqq0r8a6USb+xGOqbBqnORi0W5EqAaX3UyTjusFJ2sKMoLUKuDLlv6imNLXrRl6+lfN6BnWSU6EkKUan4572R2bJ1pxr4TKryfIU/ASqjCnUw4NX7vXER7EVwS6sq2RLSK9pPIp12bUCB07dDkH3eh3bawqFeKUWUw9YG6SITl3MQDrjol72Sgz757tEooDtgS7GudFxHHyR5V8YlAdcQC1vUT0FhXBy633aOe2YN27WBbeBTXwx3YdvvjgE1V4xDlslPQc1qorGv31me9Wn9HI+qVpF6JlN0aDG2Qeh2WtZRnq52Z+2N57WRcYbl0ALcFzWZVp1yJKldQrGU1O+fi+Yhr8Hg/g/lJWQrsUGIc4roP8qTEHsdHYrp/50mJsEe2vq3dLrJdv0nnkE74DXPMMIPmQsd6j+sDxTlpEWn6ztydHb51A1wzrTVOt3RqAu6Ia0WxW5BSrsN2NCHwjfe5RZzuSMsy4B8gnJGy5937I7+kl65dVet3b0bnaWkpQ9zivUJTTD7HOeV46lOedhbu+azSHCtDpsEBvKEpxWY1UoGt0Cf1R+k/Ygh7Ki5phm0U4vTWwIO9BxZCPFgiAlNjTe4HQP47t0Y5Q4jcB/q6uwIXNlmeNa5GTe4EXEx1ERi50xbGsmbQg5ylTd5RGoF8yLx0WjR5zde5kt3pGAA5wiuPRWyt8nKfRVyQ8zLJt4j0hyvnUC4ITwyWCQWu0OajikWW40oC31UY862qhUxYhbBVj2zTNM8Da9ccmUjBjh2Ye2LPoE0CnrZynKF6GCeiafU8yLgz2E+dSpHThLF6LklG+LicoPUatMdzoz2eZJ5gHNTfcrQJXc3eTf0yl7pMWOTg/qHXRdDoqWkUKzrJzvlBrjht+XUyYpxZ1pf3GQav0tO/qyc/2L8vR620AU2AZq+8edx1afOSpkoj5g0Lvay/MEuODQxv5ExJtvld5vyR9x5aezuwJ0OYZwnFEsL37975fh/v371/eHDn8M5d7PPbfoVD/Kf8F3/mvTqqnVA8QJhmuovA94BXwV7XUNyOqFacWm8M399zI/gJRmBjzdpg7DG5tW+qrMk+eC/V6QcY4rv38f6duwjvGny/NnjrmUEvj9kEbIVOWJsSCAJ97N+5i+8M9tEQ5OVaCLpOxEiLTyX22LoO/do61Hu2Gx50jaEbLRqFII1/Gdnsvbv3ERppCSt0a+LWmgPsrW+42Gq57t29j+XZ9Hb/t6aKsQ4dhReOhgHXwE3lQKOTrKrcPHTs9S0p1WvR4NIsyN7ABhn6sR/HT03YSIaAQbPXR3j+48BmDFRoZpOxbzP2celnHNiMA5z7GYc24xBnfsYdm3EHV37GXZtxF6/8jHs24x4u/Iz7NuM+nvoZ39uM7/HSZSw2W1euJha46UoDE9ItN54RK3HJ58lMrjQNVnoOA5nJlabBSpuMfZuhV9pkHNgMvdIm49Bm6JU2GXdshl5pk3HXZuiVNhn3bIZeaZNx32bolTYZ39sMvdIqY245sD7DeQgLkpx3yV95wvACtCnVYuhEjiHUmV4InVjiBahAqkXQiTlejA9U4qFNzPBifKgS79jECi/Gd1TiXZu4wovxXZV4zyYWeDG+pxLv28QpXozvq8TvbeISL8bfT7RXukuyK0pzLSiHsuK7xOdWPDa/DirVC/2FkNmQQOEFmbunGGzjzk1ot8vmlWFui0u5ZTpeu4ZhsB46J6BLNlfJ+BwhfCk3UhfVUF0vOsBcF923RTWc14vu41IXPbBFNeTXix7gXBc9tEX1WagXPcSZLnrHFtWno170Dq500bu2qD4v9aJ38UoXvWeL6hNUL3oPF7rofVtUn6l60ft4qot+b4vqU1Yv+j1eQtHzOF6Axo/RBDhH+O6dOwd3HZvhuXmcRaDloqoZlaW7+4NDj3kiM49LeI0ThGfXAWwbQvePnzB4u/CMzHdfrIttF+ti28W62HaxLrZdrIttF+ti28W62HaxLrZdrIttF6t+wszF+rZxvi+3kmghOnGwn1565PvcEu7qdr4c9yeEmWv5cjyYEG7u48vx/oSU5iK+HB9MSG5u4Mvx4YRk5uq9HN+ZkMrcuZfjuxOyMpft5fgeaOqqW/ZyfH9CpuZ6vRx/PyHLgDy4e5hekquNHd583DcapN4w5+OBSfWGOx/vW21TN+z5+MCkesOfjw9NqjeN+fiOSfWmMx/fNanetObjeybVm958fN+ketOcj783qeF05WFR4ikbkGVmEcFLctoTPGPVvORnCavRl2Eur0UIruXWIggfNvPrZGpbCZyFe9VeBodxPe5tK4VXtRBZW8vhIij5/a6SeFoLv7K7MF6izeZc2ZSQS/NK78IdjTo8sDyjFeM0my6yDwWNlNlLK5GQ1s23/xkV4Kt77A3atIw1JlxiJgl8UObd6ztjnY0R/u/CgP1evKu5lF2q4C+2y7zbRfrmylUIGFC/k106VduMRBHwrFoqZwo9HOcTzCGCTBZikd1M64d/MdZV4cxTSgrmvQPH8ufexKpKwh1Wlcv1MGwGbZLjAvp0u0i/4hVm4woWJpcPeaYecm5zgHWkB5PFcRk86dlNn/Ry15NeBk96Hq7GjR/wrw8XzXetuvm7VhFWeznk8Cr5erSMphpL+DJPyTiftF3DBWHj/gRPCetVEAFmgIYVKdz1oe2oCrxKpghtMn1xVE1Au/6a8BgMfzoesWLpylU61AKXx4EeonGqE3B4meHwcq1xX43ZRLXBfeZrqW090E6dwhI5xVG5jqW/jnrnSrmC1gLkYB/zMskwRRulldsnBPp2InQJAKxLeKAz6FbglxYrbhef+wtZLFsYI0NghgiHSSomiHAYpGJ+CIc5KqaHcBijYnYIhykqJodwGKJibgiHGSqmhnAYoWJmCIcJKiaGcBhg/SFxS9F4SEJjYOYbAesGOWZjPjFtIrw3cMv+szNvaWiAa+VvJdp7wJ0nRfADpLUA6+c3UhLLqGu0pvNZNwLxOLQWbSmgM40egLHXseP8NtdOMffAfa4tAXY5mnOp7R4cQ9EmALfQxPEKzJhR3W+W74HV86FVs32eJGi4V3PXObhrh6VPcg4GFH7AAbH93LE4TiBqF3NuqtE2j6dUeb+gyJNL+t604nib25u6BjDW94l/hfiq4WwytCaWo/bOEnOnhFKqdP+6eu+CevIhR6kT5nMj+HDSc24VRB7rqi5+CqyGlq81+0uQ45EP9u8rs9c/8lZ3e2NaFxKQ/oREtbQIQ8HQB/FAlguS2oq9DP3h7zcqhQW8Jix3nByYSjaprVitp8NGpbaejBuUOxMS6e8I001ytfH8kfzedJIZyPxYy9Nlrqjg6fK8FRjhJJ8MbTsmYK3IFJjxusRJoFQ+Nl6F8M3hXVJueXPg4mjOwcr8/uUc/KbKmjWBDjbNrwkAkZH+MPvB+M8fZvJSz5J8nE2w0OpuSsvFdnPjyYva5OFwGKxLaCyrIZ2CtZY3MLBhBvvwK2ZoBAKy9C7YtLFWOVgIaqG09JrCYa8Supr9ifYWLaRvHflP20a+5ZBc08+1I2/01xy5PnUpvHr13sJrKAX1Am9fdZNXGrjx73XPKCBWczHkGlatcd1qLWbI6Wu3vCAaSdxuXAT+iZx5q/m0tiBtmgiZj1S4sKhgtBZyIQbpzypxkwXWsbIj7zdbr5s2K8qbXUb2Bu5my7OEtgR1fJsnVQbmqGVo7P2eIcDEICS4W+as1oxGm5t1K6LbBbvlTFJ80NyKnGYJt5Thsyx5k2kEDL/NlQLSWKKG+cTrtsqa2js18/ZjjnBWTyyE82GkbdpTgU2RlGKNrkgESAEexyYM5QkH7c4S21jlaY5rCkspc5o4rK69ZDWqEKacl/wJ6JryNPPgepXV9b1Os4S1L88zszyKFcL9BSq8dowxEVlkOoby9qCHNe3r9Rq6x0G/j/1+WdjvtNmv9bbY9N7bTNkbYObJdSUptMx6Vf6Zjq4WWXVyTjnPlSLwIquO6ZLTaSbozGWwTarc4mm/bm3u0dQTt1TLQfVchwf3D/tGiTKOOSgw7fUxI2y9Blctuq8HdJGd5yVH4BTPxPdu62eeNZMBYstGrG0X9ZtAbKLr+94gfOMlQYA3Ssy8vYiLaOy3OEp2+d5tuM4TPm7tXOOJCWD93AYy6n9/14To1FtgwG1YuoLk1sH9Q4uUrzVqoX3mkGWZlMrNjnG7Q0r1FzRB5wpmfuz7qn2vYbP1fqFh2+YI/Vzk4JOP79glZM6n9vTFjfcyPd6EjeRE0z5Srr+WZaKjQdug68pbkAqq3lzOzdBPA4vUUjth9MOn/8kTjiak3GyAOCDURG1Pmv4ef+IbhDBFKd0kHCnLy6XSMHqeLfHcfS7sp3sxZpmEAnka3aHBFGHn1ZAYr4Y6V76xW6Lsb6+0Y83jeF7v3XOVFmB652VyLle8Fvt1R9xXpZm30B0EuqKXWQITh9B/CcJz97mwn55ztEzTyt7tZVzY0GHz5nMHazyRJx5sCAEBp1sRcOoQ8IFBu8E3UIkwi2O4ymzyMgNwLuu3u7xldBRpHw9h2nWMuRM2mr4HN6xGsmbncz3IDXd4ygZuzJh5nuU9N71J3Sl5dzBk9UUJKHqfKTioOWoCwk2uS41X6B49nJsLqTQXUr71QtJqg7i0F1Kuz7e+iEhuLqSN98CfZbs4gMoWuhaMQa8MqGctttTE+/uH8UJTkYrfjHqBtqHzL/ePR/DLVxrBReYxIhRqEYRgwj9ZDMPHLd43q4Xxj/CvrfUetnUHpAf+1q8gp/4pw48y/DrDb7JtXBMdqro/IZH6VPyEMIjUYEKiIEUVqgVz2pdttDBSjHvdA2jF8CbG1DdPAjaH97vJvPiob8RHGaH4dUaE5yeliabp0hrV8xrW7iX8lK3o39PMMlp9BqZirv7KkzfZ+FPmDjv0+VcGCpJI99PQ2wwNt3yr2vEE5+RgmP+Q8dMV2Nb4LPxynN86mBCbJ0m0Jt3GJj6uKUZHGXh9kFha+sJ9Y2ViY91AuJEzpEA/80E/C4zq/UMQvFkv/8FyPW9bLktj/M9YrIPaQj3/twt1FFLzv+V1d4wKGCeYI4uYDUCMwsf9ScoVl0ruoJWvOR7V1UZzoJqilMw8LpUnZxlnE1yQcpxNhvfjyjnuGScLUtUddUEsd07nkoa8FXWTBVn0OF0W2ZQmt8ff/l+T26c4eh8hm3iSYd/rvA0uPJ5ghXk39g8492Ph7569s6NbUZeOB5OeKJ+VF5Q/zCpwCo3QhBxnSYGMhzjrlnKpeHbT7T4q8nkyDUwWLeNk3slZJ0fKXD4pSD6eT9CIbol9v8RzXIA9j8muB2qQ74ri/7WJvpc4MltCou7Pr09e9Cowzs/nl4m+2PeN88eF56PCA6ZfdkESVDzJyO1kfHTrzwm6feou12N4VAS/tOR1i48ALV7t44O+RLqnmZgu3GsSjR+9enXyatJ59GlKl+plXOQF7Qh+mbPTjig7FeV5VuSfKYQ3g/MR+W4KsgaKBAhSw+nSdrGHPRjWdSC3gO5/1/C+MEK0837wVQZ08K8GI1t9l31RoC/nSUHokK4QbqCWRfrIFT+m8zqWVIueo0thTqgkgJWlqXELGDhlzufJnuI+DvdYHHOZmZVgYOccH3oRyZiJEwZRafgXxaA/4Q/Ls6WsuDUsgInWptr3YpJtNYjR8a/lkv73RKn/o9wyxK8cSWF36AR/Nd2C/PeFdq31//UivBqC6I0kglri3ZoXaWiCPqi1d4RsG8x0B0PxQ3uOl+h5L/CiOnmbHZ45Zc7NrL2xIWdrlC4WXcJavCl+nTi8zqHOtqW62tSW6upJtgWCMXUE8/+5hawNDxg99TX8uotYMxHWyMa2Ba3zT4ZUeYulaIg8n40uygz8Hvn2qJks7V1pygdR0jhZjjVhMRljiGlR1a8BQ7LhF+Vse/gYHfhRvysai67KevhInY/S6l9ckkFksfIUzN3bmVYSj5LIqfLA1UBOPU9cDj0tJ8PWySQa4M81eOLwKfU3KxF1WMas9UxYj1BbQsPcGmhmGxHAYDuIHW/NnAbW7Vpn4xsI+YozcmswFG2cL2UDrYp3uxkhJJcToz0Q+iDfUbkAfBNwzfQnvkE4+yEH0z3aGrZS4oDvFEMzZ7nsTvM1O7N8BtpH06wooFhRnp5CjF6sG7ORulaJpJHqIbGeZA1NK4nLCy98CIJATtrbnZ8xDlgAzxoSrE8ZzsmjDGfkdQaRsT9lhA4NVaXGJYubJX6UkRy/zkiGP2WkxJXDm/N5komEovV671GmyWQT7TPcX3NkO0aPtZwrnw3rdUKJ8+DgY+sI4b8V30ouDsVvs9C5rPx9ZccIPgDeZQmwi/TlIef0eCvqeaNYoKHMsD3GrOz5s76ga0EoPZtTgWqhfyA4eSMQtW1ABzFvSUxqDVE2294MhDJvJNWbuFhQpsaas9PjkgWh3lqjFTZqjK7JT1D6kpdneUVNrF3lcUxHM/p8831SV+csE1ktrqRMattET/0ruDQDZbrnDBoSNKE9lon8HCTOaJO8Y6ATtzWIZH15fWWzm0ZSr1eu78/10WN3BYyFM8SJPDDaL5FWG6IXnb9YwhRtztGwBP4BofgJS0ovjErLWHRU1y+MAQtSTxiHaTuOn7BEDuSYJZqTydDN4r/u6hBcEf7T3jy/hK1rDRCBufwrkCQmeRwz/2r7i8UxgwiTKo5pHXrq4W7r0R5dQNYtUTnVCEo1ApzLv8qnZxnHvD4SHoZ4zXFZH0+QT1vihXpRWf/NigTBXeuD8DPbgm7uCsrcBghtMZm3wsNfu+DBZ5ORuiK4OUywBMMyjsv6vJOyl5nq1ZiPeDdKo65IBViX7YyfqqMRtezFdXFb1XB4Czgk3B8OGzFvOKANc1201iZ4mFiq22FDwkQDIBLWm8pqQPKA7eGOEK2tAPnvOx1sAcPtsV/bgr7eEAwqWRX6bdt4Lzzslk1vjzd7gw33Ot66xX502sakt8YdvkHnS1U33z7znbGKtwRkzudJpPjLLnwjbY5HV7dKG/KwhwCjSBr17sG3xNo/ZNOPRCjiwonebxqv2XlWuj50fBDMO2zGi+R9fTth2O/GBgKPvh1/3R0GWCJnD0Lpq1PnTQLYp7B0Kjym4kFan2I9LyqvwOW2GLxl771RBHRqIoTj0po6JQJ4Hw3cYAtip8w3ygxdlRnZ6w8Vu2LBEjS6CtU/048Z1kh7WSpHTplJeeTpR6crkxr4ikoLk/xCT+AVnafTDJdafcvo9KUzlxa2cJ5hUF5xmmKXmXJGbfV8odyFTrVSakh9n2EvOHr60AzHt5tJt9Iv7zK9376PzldZ073n06zu2/Nltknra+mt/6a+qnnrqj7LW1f1cd6yqjxvrupPfMuq/sTrqypTmqv6U962qr/mwap+m//7VW2+HJZkqQn2vbegsQ/t9HW7yF5Jh8+y9AMYy9U38NqmLBVba2jTdOdGaC0BWwMuAwCE1hJcER8ibDE/Ebc7aiO0LdUV9oDHFvXSZME6QBHaSPKL1btvTYcBBLAnew8SoEgDGAltSbRFAwgldS0WU9QDW0L9XzJTU+DHdEke5rjVxs4ulJ8oi/pKL4EKTJubL0IbSU2PXLbQK+tEss0AjbzKN5sEtajsqRRwNtGb8/LM1ziWOH+QYzROMYf4g0Yjo5NrpoGnzonAjVtDybM04nzrS9nq3OG8egUuIHvqw/rfr1KBdc8pw2GDKd9sQD8Swj43H0Bnqd0G0aqae18xXa/f0d6Lt8+ebY93D7eS2CQ/CY/r+LflOtI9IuL4pyzx9S5/1dJkJZKlkO/bePykZPB1p6xHr18/evXm6cmLDsjX007UpUqW/1tGBnfxnxnp418yMsA/Z2Qff5uRA/xHRg7x7xm5g2lF7mJRkXuYVeQ+5hX5HpcVGfRxXpHBAGcVGRy6KSikXTnJzGqBskC/cqp+PynLj9V6XUsg4wlCGk/EzQZQLU1Hw4rj5F80rBtB2FWBpEZDLvUGrXnbsqoviYnzBetxntML15X91daFqYf8hGANvrAxf+rn5ndYf/ek/UZ8aws7Y60F4sKsw5z1Zeh68hNq/diavlWFbX9wN6bjP7JJHCfLKqFjUU2w6OUsV9uOhbqc1Q+GsCpMbg3uec0tqzoRyUciZZKInFfgH9WVnVd1gUlNh5fsIzFm3cFE4eJ0LMZsMkGbaMWUvGvmVLzZ6TE9fw4szMTLt+TURc5m5UUcq7/rdVuZihbzOJb/tuefFuWHrIhj9VcHMa9IH88qcojPKxKxU229dlRF7iBfVo7S2dsz1BZcG6cVuQrZ6+0ozKycgoBr40WZPdPrB3dZVC3KVTEDH9tZUdAZ+FjvZOAqOkJY3oc95SQdpILCr5F1om4LUTYghI4iPaO8ZFHahxRrbRml+5AAOh/pAXwb6Woa/bBiH1l5wX6MNonwYfqDtx7KrVIvr5R7JYpGdNyfpJ6v+otKy2f2waG9m4Pn7yETmbUzGf+cTUbw7/j3bKKkJxYRVLUlfTmicCjHfpoyHNd1nHKwP1xTHITVow9V0hjWSI0nVe2jcVBD94BqXTw0c7w18FqDsnG8e97jrDJPOFQWI9m07n0sJr3ZJcvO8ukzu2uyoY2xWlXNhjLtD1XCzPIwsyb69++ZUWeWt4sDxkdVzVBelhzug16/G/oQeedUwu34l2yCIxC0HmfChMmMEBYkoQSyEbRkKBFX/axKBD5AOGxRwKLgSII9fMq2vGiklW/dJ2kAOrqsEoFGIuQcqxIpC1M5LvFeH6WDoKLP7ZU3X1rnDqf72vLKG6v9tOqHx07Y0u1iEQhfuH9+3oTQMv4zmyjoUlJpT2NtaDajXmjizLLkIo3Un1S0Q4uSRjnt78pjTw5NICO15UjBK/MPxMMqYUgfCrmjHpTKn57uuJkYDNfCeegpwkwJJlTQjK2WLsbe1ufk1kA9KIbPZh8O+aaMkg+Vel66g8kEaZmZ3kSgB55pzlsii2M6ZtUEiu9PJlj+PZggDO2nEVudfaC83kHfVZpMUIJSiA2i3zXTmux8CD+JilqVCNS0bcRMzX6oI8KpaB97JBGEBc8/Uo+ueskRNJZwkjAikKwfxwwWcZkv6XGjmgRkrG4UKJXP4lgC/DhXrphuAsoSjGV5JwpUdwfDHP4+rfDLCh9V+EWFTyp8XOG/Kvy8wu8q/KQi0fv37PRJWYlnEpTev4/ws4q0yl3x24qM+7g/wY8rz1ffbxnqzfOi0IU+Q9jJBxXZ63t0gg/L5Lnl8r2r5IFVa3eiv//MJvgv+B6AxiVgQEi2SOP4pFKBKN9o/yQvs6rCT3XNvJpgDaBxnBxVROAXFUgJnleE4mNd7Ntsgj3H97/qsYn1OvlcrdfLKnknF8pho+aHQy3xX5VsVONmd833WlInz6sxrSbk1gDDrJXI2pE8VYKuZDfTKnkO+yGbarcmeyOLIA2ARAwFgQcXQcwLdeB++C2zYWjEeFFNPAdMQuvFsPGsmrT5gJDpYz7BOSnV4x5e8jlsRfQGInycrSoBSExRlGB6GiH8c5WUWJXKx7ya4H20Acm8v4o+UeP9rq1l276SBwBKv1XJSdVblJV4oLWHw/WytxI1bZsAR3WD1zDbad+TfedfIiwzFpMh7bkQKnCbBCVe0TmnGvOv1+0OJnJBTrYOuDFCf0jlSl4q8hpUDSWweIYc991+V1tbPam8wWsfOjRA/Y0Ot7xwSyLGfDIsg8WO4/B3wuUdq6Zmh/Bn8OCrwz0W8pJxUUj276x1UJJbAy+Z4edVHD+vxmU1wRSX67XL0wW9t+uXqs1dwYtqdFSlR1UcP6ySI4ipn8WxioBACHlejTL1UqrICiuSvKhGx6rGUQUOniS8rNdQS//0PtWTniAd9G+P5HjakOf5bhiu1NuWcgjskD5XobGeGjcFbGTsNU0ChAyUT3eJdZ9pjr0htyIMOuhi0sd9nGGGi1GuJwhaGwpvWa8BPURTtQIkyUdwZGEAUByt13yVCEy9XVEbp2w3dHhY2v0tuCGWq2SpqLM5wJm8QPJ58rwaLydkipc/Wu+4xihxLnOgqyUsl+kknyd7L2ArTDjYo0qNdjgDioEs8MzgTMEKxHHSnqGroc3GzFt2jmUvyXGlTHQTdW+avtQmA0BYuFGLZ0sAXQBPi1+F6C6Qik9FSLIPQe8L4xY395dNAdC5xOKAH+bQ8vGTk9dv3r84OX406WiqkZU6SNYHSlkHdAbBmkTevtAEmeIHck7ndkvtaAw5dlSRqXoH8dTzqFZnIeCcvKhwRo4qg+cRQ/v8Ioeqv3k1ieM95yAMZavEZWljH8Evr1SPR3qtSyIfQ0U1UITpKkHYNZJwzBDej/lIPo+pbk/OaMujsJnnLCuKy6tf5ROk8ASOkJxmLvt0Sl2eb7YG0+TvCmSDoNL4sjL6c+YrQZiPEhgpT/6QRIgcpBwgSgFRSIIn/MsePCSftbcVwuUq6ePfMkl46Cm9rJQKnvqbICzn6F+2f/iUssaPRgfpPiB7v6sFd6iXnMCVTvXcKq2aF3anFdkEuUS3i6/yWUpdUBoBNxs4yUtLzNxFJS+xx5U2nELYEUPprYGJxPdaZNxFz515oQBlE409T/f62HLIdFQlu5omypJb9CDlYa2gRercz3oRH7nXAZ5quLvuQZFF6of/RAYDMIEQw2BQpisz9Vf0NK8Ev0xb/CqwEUtQymAUu8rxEU9QyvFUydJUIMaqHpmXrTRP3m32dJXcGiD8stJavUzFm9/q/KYkTfpOkukcjXiLEpVAKVdOFF9rTzwyCaymvEHstURns9y6TtRNWvqMJN2iwrQBH854+oF7c16u2CyNUq9QXnU4/XuVczpLI9SNOmPZbmMlgXaTT3R2RtdrljZ6ZiOWqhuSjaIojaIuQ91oElmpixemja9a/TS1nzXNlbiS/aTGtYjQnkn6WGSnKs41zoTgVcqxRMYLmaYBSj8RTxmEdtY2kXnwy8R91j+FcgCWY+ZClskz64c2S0vc9sia4yKy6YLqCpW4LHJ2ao6vDSmtmZt1aCxboVEovEJSiuB9JmBHsSY7iml2lJVWfVd1FnbX9VsK72jGOs/Me9vJhBp5L1L9ccI0GrNKOIrjuzHXrPpweBS/qxAuVhBL7101phOfb5SvvOv5PiHJfU3Cek63Vm3+eNzl0HDIoygTky2pAk7mq4ShGsnG6wvRXAZJw+l5d0RpFyRC+FuJ21eyVcz896aC0dZYir6NnW/vNJeFAYEaCok4DJGkWn9xvEWPTbha+Z6kQP2ulcv45bOB7TV6Zb0INku3JgK79GIVqqVpRgUuFfMHSGPz5kEQQfvqAdYA2IElBDRyIeJ4YIQ8IhlgjjZJphz55gk83gaRwKEUgsYxTfaBiZSB/xqH5HB/Q6YrX6wKUjnyvGq09iNJxMgwCtI+UuimillJPy3B+58O1Jl1zrMin3Vmat1m9FOkHPGu1899UnO5pee/M8uRwGD+qeJi0m7U6EmAeQtlM4gIy3knUfXA1a767EYo8iVY7fCnGs7ZacdCYue0FMCRjZDlyT6p2tjaqokSzLrkswCBcTseSGOhrM5X5FnluVDyzvaV95iPJ7iSMLgqKE+pwgzSxUpZrp+vrrVlfu8bM7/PlstXdK4QZ5dtr95aXmGcLHqJJr6jaDNueF9RYY+U0d1o0XAMBuVavIkxnEah6GyrLdyBpJMOtBEZ9KTuyC8ybGsxjgB1PaytrRvrFsf5KnFZyBiJNwr21Ku2Lde4PgbFRbRrkxC+rBIQs3jdau6u2OIL2fPt416JSnH+8YrcGgyroYlSqR5s4lOoYIFPCJmi11Wyj0tN0Wt+O84QrtoFEHEcVmiXUthmFK2n/UpN0dWW3oaKfVDhOVm2Nznakq6EGUv1JicFmXuMzNH7KoHf476W88nNzL64C82oWeoPtDGTGqhJKc7FoypRXAEE0dS0OM9iNeOqkTQZfqrG3e5qQipckNloYUnp8SwQgEJ/BXlfJRVylDcpgIunfyQFuZD5KI7vD77fj013xnMJZH+qxqtbtyYIDas43iuGliUoG6jIQ2hgva4IISyQXlWebHa97u8RMoWIm2YPEdbdbyqi2E0KEvtYNBibO2VlIHgaBvxtSX0PDY4Do/GY2z+S37KRqDX2460B+El7IylylAoPJiBdaKCA9UbaG4Q2ixyKON4DHnociz1C6BC9AsJekI+aFyB/r9fK12IcQ9mNIEx7MVdM/oP9UFnaanw0VcwwGzJCcYvYHwRQ67WSS5HxBG2MRay6I7RCCcKinRES+k63jXryOmjc+6070S0L2a8V22FjWedN6yzjHx+XHMhj/4rda5dWUC2oMGifWqtDbPA/TVkObUYN2QMJQsTL0rxJEcKwn7yaIDUHQp5V2h5D/pKUopZUJS2LwQndIMx69mX2jXwzwHO5FlqZFp9VG4Q2/gtRt8aTr0LDGM++XzG59X3dDEPhp9vrrMn9RieeIzKv3kq/Xfotrlv8ha7Jtm3YZ5DMSeQV0G+LZILcbrPZ1YOayZvyXf2h89vf8hbStoV8zMuzI4XsNJbHQ4LaR1GvSGs1qTZFuFxtM0VAoesfkA4aw+5FXmFr765tE3aYFGhBqUWrjCFCC1j6OlSKBicGlY7eXC5pZ5lVFZ2BJyaFmNpWQVmzk4vOrKSVYw5/x05tkWM6/66j7Wcue2A+Huau16CEicCP88UqqedrzBl0PT/7up6nHrU29pzlgBosouB49oJZfJABggNXzZUcDzAuQMxk6CnFytggRxnK9s5WcK4XNIlenZy8ef/w5MWbR7+/ef/m5JdHLyJ85byJpnBZRNio1DaRzNkq+Z0mH1YIbTYIf3Atv3745NHx22ePXv2jZjn9e0UrccTys0zmPObZGQW3AIlSfIPuLrbCnefOfpv5C3Pk/jGdE4G9BGUSoxTMWM/wvIiwn9W4L19AzGBrgQtpOG8VuCitAXI7Qi9Chz7LlWjxjqIbOrU3kxt0T9X5xw59gv410+rLBqAr3WAEO62DamISG0tLIlK4InzEG97S09MKr0g2Skr1pJudkcRATqpW3mpz/EbPQ244Wq+fVmiU1wy1S/x7hTQvkvxeNfNRWkt68Tr5vcIlkrUSUDEtCI/jvaw+jbMVSmer5HpgR3hK/pQIcm1Wq+umhMUqCWXBjsfcth4le7mqFqPDdB8Np+OymhCubJXVqJXkWJEbeI4X5O8qmWoRo3zv8nlihTxOxjNv2ekXoHigZVdDIx77pUr6+AALb6x/VsnTCiclYU4g1mOnL3l+ngl6nIlsvU7KMIWoWZeYOdn8MZ1XmGkdIfi0fCaEdH/e9DF3Cv4g/st9ggAcdEPrL1cfinwax+5bIj2BUgAZswmEWuvjlv1CuPDZknCbL9sMK71H7e8sUSow+NYAR64nj2WnAEV+zktOOxm77BjPcFHA2/07S15UeK+PoyWn53m5qk74S2v+6DMBO1anccttgp9U+Mq/Bwbaj/dRtTFkwju5ls+rsagm5B3odeNQ4K04v8DyJQI/qAzb8CigyIYQVqz//Z2Yo1GYRegPPwwO13KHYr4epP7CyRquouLWvaKat7mgnbPsU0epvXXKecctbIRw2Em3q8hYG+vF7D5YGScMbQK8h3nW3XF8UJN3+3RGqEd+KYEfaSUjq1BuhKvCxJYhhJRIBcLI50lJCDmvEO+Sfcs/2Knk9tqzb+92cR+aMxEjxrw7mOAMPvYnuIKPg8mQjZ5Wdcv4DFc4R2loMf/idaJCgWLeJYeKGK9Mu22tlLiqt5GUuv7+ZpMcWc6Hv6xIYlP9livNuB9CLWcvZOiCOYZRH5DYvkTzj4FUKBVrqyWxldeXzBUnfIk2yTzQQ6mzkNU+A/8Vc6IuJdCJTJp3ZnhqeYuanjzGr9WJLVlx6SnRl6wDxTvmEgUcOEJYgDm4lf2u1/4vz+4CWBEsjpMblmYIJ9yztICi0zbLkT6YcyPZQ6+EuJVY9GYqRiVuLBgwLxoz93Ty6I8/Dg7lWnbVOQefHGxY/sDB0ZaNhOKpnJWTYVUlORa4RHhlvwrztdkkzD/9IG9Ytt3lwg5kRvr4nMwbXCuJHV6S/vDSnedLOSxT75SI8eUEnym24wf154L0hxc/nJoKF2Ye7+WL2e3O8AE+HV9MvNd9+GH0QWnovNd6WWfmC38wX5tztQNnaPNzlczx3GqF4CUeIPNbUd37lo79u0oWGofQihRajwKoi4dAAryvY4tAWC3xFFO88oOcJg9B9w08lDlGe6D8oxcR4YdAMj0XCL/fjvnXNde2UwDWx/nDD4C0ZzaiK2E4s8OCSEG1Uw9zPF8prZqsbQZyZ24N8H4d9+II+lG3ASlx1gNtTwkZIJZnSS5L1EgRnO2gjFt49DXGj3ImYOaKI2Op2MkKTrPZZcdJE6wnCFO6NWqLYYYlaNOooBkK4lr23dccJMAxVfaTfwmEH66IITjTzwKvKvp4K7Ep1/1ytVFBSMaTDf60C7qcT94mXLW7UBhPMA9BTYd2ET3PrrRdhFZ66/Bd1H1NE4G60XdOoFatPsgllvjKd6akhJnvehHCWwZU9mwqdsh9A+nUA6pxUNTBd/QZsIS1BxMi1utzkSjOxyXECFEK+5jh8cOV5QGkv8KWgE+LlG8mCLtoyqRGJAmZOa1xfV4pZhAnau8w//+Px42Px6+iFrL0S/kmgdsQtrmZ+w/vrH1aNc2j5Rv7k1ZKeaTO7myl9Fn2+njFizSKNvh1IOfd4DerFp94dT6nyEVBSfRQsyQkqk+L4rKz4kUn6j5a9Va8AKX6j/+OnfRehTQR/4T5o9yW7/RkfGp8wHwhs+V9tfpQTXn+wdsPbz5tBd0ksfD9cu2x3rQoKzqLYwHIhWHjQwwXzEKoPm04uFHYm6yyyCpQQNMKaWqf5CeDZOsJWHXnqa1ROvQXRXUd9ssCYbtAV3X3Pf70XCNEW99zivArxcd82Xqo4TICp4TIDyXy1FdKoqMtsO816fv1MAKUlvBAIuhPhSlLX628CBmrfxUEQQuNQB+HWmnVxAQAfZGUaER7y3KZoLQ0Me6p1TvX4Rj1YJ+uktKE1jdp5eg3MJhOwbSuP8EJb1ldtTUJQzhcYNR7n1evp1mRcbLXt5HMwBmqiaxuov8ou2zAQo92iCQaRxlHrOzoaA1VJ2ediv69omxKo8YhB59U0aOzpbgESI3M6VYesxSUncwT5oMkalwJYpMo+Hfw82IVGErb0buHmPWKfC7AW9bJSnsvVfEXrld/WXI6y6eeq075zxE/bddfkSuzxS9Vz94SymcjDCToIWjfuNHFx7sx9hZ3VVg0HFa5WTBc2ilwXPam5YoJ0t/plOo9a/VVCZxLLRi2HbhhmG6wVdNZMXmS6qEqFJ5kH96cAVKv3RRTtBHWJ6nLZMojJtw7jxD+68uA1hzjTrkSEv/jkkjZBrJHuvDJSpzMX8mSXwV+8fOtsOdue1GKrLCAJ3/80Pfu9L9W/w4G31kYhLYtyL37QjS+AXBcj5wBBqoAbBemuQXAiBsbZqTbdWA0ZD+4MBotgIEZIe0F3BWpZr5ibk3AdzVAlOe8elWH1L425aYaeW95l4S7cJ6tVKh5OaFnO7ZcDxTuZfX6t7twvvHmvrWb67dq9/jtv9/jYLRyq/MK7nd4br5ot2GYtvYA7zjvfjtmLxsSet3UtoujuSrNHr2nVF8yj3c8FnLJlOtF+kmc8JMPFeWSytI7AHcZEY7xBaNm/26DP9sNDjv1ugw7tHv/+TomkGH27dr/vPdeZMsXcis/YvVDefI3vx6aeYbZfL1ulChlWpEwNEpyua1KnzPHXh8MpQykSTabBdlaRSzsS78iLT26DV6vPyKcfxm4yncPEGDdvffomeFJyuxLH7qbQT1txEsIxgMz/y8akM25wTn0x2SWvWVYXzyo0M/nrgP7YNVGSNfu8L9XCAtytcgqxVTZGyhrk/qVYgqQvf4Gm77SkELbC0qaGAIJ2mxatezcI/F4lQjNGdJ/ENpoZRfPU8EqZL0debTMrytfLFKnYH4k+8M6euwF0QbhbkJHL1Z+tGLmsWO050aU/nHNTJ6vkoG8Z9joySoRKH2waqHM9OCDAAg/fQkW/5sxjdAP6283uZq3Y/LqZ1Wu+PRf38p/XoPX+33ZC/nPr3Mh+1h+7mH5uZlbiXOl4Ev6foH1Ot95A7JS5PPLh41T7tCWJgK2+3zeAPfbG3whfQET63aDBf7iG09HGwtnnOwNbox61Gv2myjlLyGo/wJQOvCsSn4ODrOLWN9yrIGJvNf3sFD/XNsD823twHx7zYGpcamtY/FsOl2drYpMlBa3qSidmSO0yKrX8ue/PEN/2DPk9ed6C/qyZ+iPr3OG/BkChgHzk2fITC44RF/OsZTt7WZYQpcbXPklqHuGYBB7WmKvhneDKFm7j5zHXoRFDYYj+OULdaqHbsfpTZF0XbtN/5z459Y/7d4mJG7bIXC6PdDXoC0+WDYJgOah/N2n81pIOuUp7OkqQalH3dHCUXe0+D9O0IuinaAXxVck6HnOTp2Ppa9B4csWDTQoap8Tn2U0tC6F2EgYkUwqxvw/2ITQG9zMisFbhwUsvF6Ac/5jH9UCbULej97QRu4zdSXMgGEmJekPyx9YoDXR7f4HG2pWLR/nE7ShTYzVQSMrtkCjtkahFx1eKNUXA43I08/NVqcLQbiCS74DLoWvAfpvOQ6lhT6rU6pWCIZjgbHcBYw3ZWjaMTNc2vnuZGLWyCbhYex59VqUyyWdmfVVzx/cSCzUkk1EMCd9HYkQv6D1boOpqPvpvcd4OmKzV3R6OS0sVyqbzZLPqgK82RI+HnjwkRfuzfg98XGHrPjvIgR+l6j+jRF9sBMsQinkqrBa78+0LkfnaeBIpqjVmLoa2XL5IKvoE07nEcLLbUAexJTSppfVCp5paOpbvaHvl0Um5iU/ey14JujpJRHa8L49u3dKhek/0Q/j+w86gVCIFr18w7O8yNnp6yKrFsm8SLi1yGy0V7KX5fK1yERoMMTscHv0LBfJ1YoXKestM7GQyCVelkv54KsofjrIO1Y+GkBHEiRfLcdaNnAD8thifqzkZ7AtyZbxw4hoPS5cXmn3+S8zsXj09yor3pSkFbZqKGdkhPHQLiKkPooudb9AG/llxrOzKmH1IdhSpF2C2LJRbbcdjWMhl5eL6rccpjpSF6CK8GcFe6kwRloGGvC8SASqD2vJ6TLj9NEnQTnLire8aNsOGsfR7WiPgAAQdiS6HXXpVihqttqIn3JaNuPe1Gx9om16Kls6XVULBbkMRxFuC3AE8eehzNfu3G97W//zkl9kvBlYsNmaLlkPWQcRdK6vLYvVq7ZoEYRqQsGd5D2pV8CHohhekFQ4phPbQBdt0L8NhEYGhEbRKOrSFEze/ipzJkEZgL72xCvTaVoLhg5YUp8QUUvXvnlI3wXFpWymzkl0O0IQ5RQHx8cl7xPCRrTrH6YBONiF1JR2JcRDELPmUW3BKGnvDN7k29+s/3O0/va2MZdVdMZ6bX0MuhtAB9Jnt+SowEiY3RpMRoO0j1DX5LNGXNN5EfDANCAmt//zNnTVW4iz4tvbOIqUfufiC5HwBgpu4c08lkSAopp5dKIIW4ewiZ/B0E7c3L08LRaL9T79d6pxDXmFnmTVQtl7NkhC7+XcFpnTjj2s2Xi0mq/V0KMrmuNaZJXdeN9RSPSNfG4MktQf1YBR1Iax++pWI1gW4QGrPwrUGRe6fqNvIHhdrTtzvW6N02ZYZPWrn3WXRfsryREa9gkpnXl6uW3N5KKz7Gz7Zrvrnyqt75r56da7/3/KBIInpG0O174ftinv/RA3fj9sbfN+iE0iX7zZP7wx8nnSfltojwPwqLaU8E/mY16eHZ88T5DzU9Dwgfai7Ehw7iw4nXcqKnqdlwWVCVpbVfnuWdHOvORgJnT08uX7B0evH71/8urR4w6Ez++UvJPNZp1MNaWViTqihAom6kHP+S8LLrb/r9xrN8IFr79RvvJtaQ7O1kO4pV5FMz5dIMPSueYajmM6iqKu6LL/rovvf9o99v+ya+m8MNqMlwUZR5RFeDyOsghHy2iCx9HR8whHL59HE3xeTGSWn2DSXkc4kslvIhz9pv8+jnD0Gpp4vWIyv5T/vllRWYbO5PdiJcvxXJbMhCk7yy5VcfXxZkUr9fUbnTHz/Wax4vrzMc/Vx+tMrLj8VA1BI9AA1IVKUByKRhOYwHgc/awHKydwpP/+rP8/gkng6CTC0YsIR8fQ9s+ZnMpj+kGWzmR7R0sO33IYP8N0f14VMn11KlugS9nGVMhWynPZDp2allYZv1Stcf35XB441Whe+M1S1e6lanhVCdW2oBCiAHoo1deL8twkHtOp+rQTfgATk90/eCg/1aRUTIzOwwXPoeEjxsrOcXmWs1xW7ePxXdyXBZ/fnt2+hHE+f96Z4Y7+tN+PHj16hDsuRdZZpGdnHQlU8iOtqvC78zn89fnzZ6h1NdjgzlV/E8mBy1+d7zLxnUmRJXoRhv+GEY7+I8JRN8LRLTmGCEf/+Wl2T/5Z7fcP+upjfyCX8EUmtzKFLr7B33zT733zzTcRVt//ATWzQ5XRlxW/edSPJjj6NsLR29ed47Io5J5fbZqxHMjzTCx686IseQKfGQTHkZcn7YnytcJBkaMu/vf4f/cm/+s/eyOgLGrEzECR0UA6jwbpnc0EnxbkaoPP2rkLY9r7k/KS9Cckkh8RlkknjJLBhEQnEnxkwpuLkuxPSPTmQpd4TC/IwYREj+mFSniesUtyOCGR/NCtiAXl5I5sR35Fknq62iD8wfHw3lb03eHLYsWzoooQvqhx+97/W4oJXJBSIJNmdMkpRAdQ/T1m12APp1Sokg8lbR86TJEUslbz1kKFeuOjLemJkTCroWGK0pZ9aaNqRfmsvKD8YVZRHxze3z6V8Cvh5bQYC7Brdj60DAuzVy2LXCSy4LivysjifOJK5vNEXuWEEG4SL4thHef77nleVTk77ajxK6+MBr3TadF3Xdr9Lup9Byr348H9yaY2bSQhXGnAnxUAgVoVPfosgXBock4YNRkloy79zYWtIC688o/phUmf0wuXLoHSZJxJAK1pwEclQKjis18UHo3/0GenYz4UhLJpOaNvXz21dmGJUE4cbPRFkiXUrPgwQghcdYLoBw338t6sZHToklTjK5IrDX1ckJV14heRCOEpqcB5WTEar3AUTdLxyvIsCoTNj6I7QBO8j/CSTMcD2OTpuD/pCZ6fJQgc7et9ndHGFJZo40SrjFwpphPdWNtV8FIRx3r4cZxwUvZUeyiOtYSjdD6bAAw19CghyMY37VcRpLZKpgxWBTDzbX62LPJpLozglJ0+LvnJ3Ih3lTCeeVrmxB7sGziEBJvorRJ5YEzaXv6pw5igwyLb0Z83I+KJIG8NvkrX9Fxia9d2/R/7hPS/SoflbKuyg5K9yRHdwLPmJkH40U5waXXvZf2WGut9AzPvZ/l8TnllwOa9hqnjnCsFZr+Usjy8OUTptiJ81arDYfqyg6v1/VUWHtp8w7PpxweX16ibCFXqMWvqnCxYgqxjhzh2/shdlPo4npasKgv30bvIOAt/JZHuxAXrsY8c7nxYiQ6nU5qf01kn6v78+uRFTzHf8vllQlE36nVeU9pZCLGs0tu3M3a6KjLey8vbs3Ja3RbVbbm3lbidLfPb0/LsrGSKB3v7hVyGW9ZlAfBkv9n7Rtml31rycpmdKsGjfMTOJDqbM0n8KMrHCKHcGt1E1+bG26OBsgVQqHX/aiGXfqEHWnZ6XDYcJBpFlADmanCp4XAw9NQmTN7QCs312Yhjipyurz4vwRHrzXM2SyjSxq2Ju8I1eBopOmuJt/swY+AwP2ezTtZRLXaq1XJZcvCvrN0kfwcOnb/rlPMOGHV/F3WTRBCKtKN845YfdaPveh0ACuXoQzdVGSc/HVF2ngq1xFWnWk0XnaxSmi5VL9JybGHNLPUcfRmzSevJP+FioyHTJgnvwZWf9oeYMLQJZUZB9hatGczIeDKkxoz6ZEk5wKwvvQStNy9kivFUpFyfWo8e4Z3ZEqk8EQ4OwUT9U6Edg9m54VsDfGuAcIlwBvj9a4k55Wio+CpJpt3XqqGUo0avKtZewlGatIzplIqESwS9lg518kav2PYKpqYaMdMxx/x4Y5rjYaLvAl+PjfkE/Mlg+OJ0WvIZGsraDsVreWxsuz+ULpZZ3lpSTWeYG2+W+sXn2KUoRKb0Uiza48PUxkLA0xllIhcabAIlgtblpD0djUNBg+3GQ7d6uaBnm5pAM1ytGlVEW5oRqhn1iL+uKxMpvSlYY/MggnNvscFvdjz4u597ayNCLzofjTdysaDMXLk1R+USNLdkyVpyui01WpLrfYgvQhuebscZWpY1SJeV7fRXNs7+TYzebzi0NwvAHevDe1UkXrZlndcXgu5ezv+SET8qqra31YxYZdsR12GA7t7pLxtxcIBc1SbztbHPo8a6rddtvt/BTTBP0BfBp8MyvG1pbbzlTWhrMDx/CKG0MZwbDX/HqWsbvj/bLxp+rcHG8PWt9bFo7JQ7iG58cAiBWHAchFeF878F4cmaY2lI1mg38hBlf3whruw5tulpLYOn2+5MdNWq3QmDea2UTpYgJmzXfmoopgitmBJeVWDxtKk/GbO8WpZVKIajoentTdyWN6vIvXkJ/MTkv2bWEg4TgdsmeYM53mRSahYIHym26NMCv7hOYfc9964nRfloI1wv9AYkv4J50Fkju/Ln7qWXH/4KihllSBYEUfeJjJPmrMww/U4M4quXqb7hgmesknRXG5vaDm1E9zRTBH4ltSa16rtpKqH2+vEXybTQskKjrTlpsn1ZG13gt6x3wbNl0shBKE2oWQoHyvYNulnzzWZrGFqbzplPOwzdZtP6TuufoO9sFNvcAAO4CWu2nKrECy/gKbyZF/CZm0ECxh2NeQSjqCtvvxeJQIan+RLCMzz0k44M+1rTkk8ZRBJ6mS+pceqQyitUSMpRkv/LfGmchVF5p0b18TTOuIV0swYGFpurhf5Lz+umDcPw1reOphPvHNlX1B+a4ZNxOg+iLST2TTypSWuOnVznWKttvCk/UhYh/FdBImWcHuHnN3mg2Kny+ykRqGM6J3OafJEbdPBuUSS/0+S4QNjzfK78W1xPVxjFE3M+VBNmVcr5vKKiqeQBIcg3bfdkRcVJrZK5zXVjwGPo5ZWKXE7RqDkruklrsQpOqXg95WVRvCyrPHzHwttT8zlU4Ve0EqXmFqDR2Jtgr4ICv+Nm2h+TVE0v1G6FvDdls39rXbK1Z30PBr28KRNwdUTHg0ldkVYXOGLTRc0A3rBjtvcV2BtZraIw8mP0TdSlEOjGSkqcuajp3UWOHHo8n20tjsGHjOZOTSIUSOe2N95gCFVUPMnldC4bc/s3C6GXfqGaHoKabFWvI6+HZiqhjTGGk2hVzT2l4kG5Ak7bwyKnTLyiU3B7CCrFc9H1h7XMTunv6tSAnZMol438P3S+Zsios2TsMeqQxW6VErb4rbIFurasWN2ngZZd7HkdxHHw0/ZXNz7eG2z01fmkqEXCfebZ8zxRwrG3BX5ckKtpkVVVGsGfF9kZjXDOGOVPxFmRRurzzfNnEeY0m5WsuEwj+XXCissIi+yDCtMZiewDcHmiDf5ckKvoPz9EafQgm36sltmURjj6TxGl0ZvsA6gy3JtHaXRMCyog69NAln5UTbMljfAxLVzmo2rqcp7RuUijI87LC/kZ4Vf56cKkwHeE3y7177fLCB+XF0z/lJ8Rfk7ZKo20L2j5I8JqQ9JI/X1WTj9G+LecpdHJ62iDHxTk6iiNBhF+kEb7EX6YRgcRPk6jwwg/SqM7EX6cRncj/FMa3YvwkzS6H+GnafR9hH9Oo/8V4V/SqBvh52l0K8Iv0qgX4ZM0uh3h6P+O0gg0QD5934/S6MXqDLreDD/Qno7u/bYg+odPWSiSs1qvm3js3l4yuBtrmd7ZMuPUvJPm9gT7GXWx/F3gX7eqP3zF6DDLjFd1/cgaDx6KgNdUSfLC4aazCFTJzrKPVBv4NOwthxTwAYGfFOt18qQgdf3ERVYZ3s0WA0OI3xJWUu62mpXAB/lYTEjTmeLuTmSlsErOzsuPLXYqGe/wYcIJRWMx0cvN8UpZHPkNFOXpo4aTFn05WGFZYuRjQEaPgl8JRalJKMpTZVZV62Fn4+FvWbwtraHBWpSnP/FytfyStk9lhfbUre0/YoHS4k16eMRmWzMkMXkDy/tMCP6mlHnPs+VWmejj4gtjsugT3w5dbwulGaFskvx6Aaawjf1QD029o4mjbWa6zXKNhmr8DzhLvWw2e3ROmXiWV4IyysH2s+EJo2RHbPYwY1NabDNw2t4U9pafaglQe59hp5LKkm8rlG1IIILcxlwVlfq8XFW0Xj3AjU6pOFZKQuaWTowIUzUcuTYiz5YjZ7lQBSje6+O9PsKibQT/svN/0O+S03Plb182XOOshZkJwlRr92ivR4PaHVm9VBXorFWx0LhXs6VUBJw9EjQbx3vB78bV/dQgOO2dWPynUdHwTHWMqZbqkQ6CH+XKthOUXypTz2DiFI20SIupCOSNnk5WYtcQS5Nd87VbziDIWHslk9usUyfma5VaVlH+014BzIMbd1n7aik6xXuxVZhttYL+GtVaBOWqhyoaQdsYXH7TF/Hr/EORs9Mts3UF6lYPEhtpI0IcWW7D9NSmL8chk9vtKL38bfWOKnlzhWibi0LpFcTMudCwQUUbAWt4t4vYmE9UxBqD89U6L2jGm4OGmKL++g6RuWHhZ+Ln1a7IbLmkbFbfNXW5enmNq9VrvlHP77pZD5RZmxXVQ+Rng+ZvW6/X7bTEkN2vcCUQpnUMsKJc/D/svQ132zaWN/5VJG5XIf5GFLu7z+4ONRytm7htpmmSsZ3pTDV6cmgJsjihARaE4riWvvv/4OKFAAjKcpvOPHvO7nZikcTLxdvFxcW9v6vM2yMEuZ9T2tnZ1efTquopgHah76nH1MLS4+WvBOmGHuhmd1cK6sjSMQarBszy1lxEuOunnqUlD26a53bquuwG8/YyRCraw+4iAOZNN4OqROOUd4oHjWbfDrZQHztVdDNpwwf9PrrbP2c3ffzooQ1fZ+0I0+qr2bB+iSSh97jEmPb44oQZftIjv3Q4bCtzphDQorf+kIB4y2xQwB65MqU5PbyS1xcRGdx04SdgCr+mKaaMnrZcgO7+sriOnyrzx7UlTS6en798e+k6RQaxwATCPEqIuKt6hk6pMx85dEkjC3Qmjszo7hHGLDvoJQxhXqMUrosluz1nrIfDhKlCn7ZrIh4qorHfO1m/ZU1PpjVrwnVQMdrDnOATtFQBAPqV6M5rvrp7btR6fUe3eOrODuoluyyuDy5Sp+2ekmRVHVnGXKzBVYXDFKtyod1wnJw4bHmxXEILupzTZAHcox6p4oGc2nwwzLwumlhOZ6BMAeYc3ymiIQJWTWSvhckfUTopYrq5vDxJ0p24kRwOUI3K2GlgnDoHvMiUDAVut0liRckpz3OacQtAEBwdOhPJ3enVx2CIDQv6vqh7pGBAiS1q8G9roxDiiG2mjRFZCnKTcjQBsP2UgU0vZmpXbwGBO/1i+WFfj7ppYjPHCcXYr9vw00Xk02uHM+9Zk/2UXHtBIfsp8dNFKGn6KNGz2SNib+4OGZiHJSgKMI+u5r4O6Xzv4Qb7+iOSJtIaI/Oc3hac9G0V/UoBrcUHuTUlKDz2qk3qW3FTma0zcjFrLw2tWl0j5arMl9+/svtusio+kMtSyK22MzmCTXpPTV28gs5lnH8VYC+8Br13d+Et171gdXaMr5gQ7CY7xhVZiewYc7gLOsa35VKss2O8JurFbtc9XUDcqTjTkZ+6B4sggz5ZwFsh+Z2fQ2NMfC/pJvGdYWiAAY30qES70SjV8EKkkQdK/TOVXJWMbxpdpFG1QpLwpU58S64+lCKSIfohFeENQGdW7pm/YSOSy7Pv3746vTwDsKMebZOsoCMXB+omCGWW53Cihkj4r9+8OAuL0eeXw0t6/ub7789exwtzmnJYYWevznoKkzvnXkHRKCxbcXE0IgMTbo+tBnKJaoJCOh8QQd1SzLr9mhfXkaJuasbFSyrYC7aIleVyEcbVICs7uJDDpQThjjhaLFnd2522bJsqBnriA56Qvm0tWQNUY1dw/Uio+I7cRQ0GPpC7iXVgEY4zS6q/Kq+HVUm4sftK3tHSvFwmEx917N1RggDxSTnWj1ec3TxfF/y5bBtcdL6kInXhn75E+OQ/EML/BmvFxBwdjb6q5Ax6c0vbyyZV8lfVTMyRlUt+lo/bbZf3flOxq6KC1l8W/JrEj9KJuvOSK1VM1e8sMeOi3pIsuWLLO/0wlr/jqmptQhLZIHxDkE5GCyHUm9P0ywGIOA7+8zfVdpt+U+V95jNXRUMShKbfVNGpBK304bzoVP7NUpFT/JMs/Sen9ODoWiQI4Z8qX+5RRcvzs8KC+6myMDjjxbrgpyI9RlPnbZY8S46c54680qhO6LBpdP9NFYlpeU3Eu4bw0+v4Vq77mxYfy+tCMD7emMSdbREi+ofSkTIP8pUFybIQxdPkKCq7dkrpKK6iRXULes5u6o0gy/C4YssL03R4jXHW+4FcndLypmdKtk6quXFS1X3vsj3IH2x5NeHg+kkX5DW77e98J529k3bejSm7ncZfpyhT0d8KQZCSdW46ERFMM58z9qF0BRQrnRxHOlemjfXq8yptFwCk6gBFNZH8cpyDfDHoA4KOkjw5ioIiAJpCrwWLvRMJ0TvE+H1hRvctJ6vyU258DcG0GyxlzuhSmVBJEVUb4oXre1l+TLBpAzLbyDAX7YGY4sTWBdZVCEWqT5IJ+C62foSz5AcQ0wAw6GeN9nPTJHMN/m19AdnREYpXzGdsfpScBrXfx6p/mhzJ1D4EyFHyNJlccVJ82Ck/w3tF0qXtoyy5Dd6c0WWCv2c/u2naPiXy6xv3G/OyDliQVvQWs5toe4wP5K5JSxQN9hvpFBCxOwNdzsgc7Vzs/8dMkVZBsBfs5UXZaDa27wowkjBcvlyFWD6ly4uObGROqGuu/ZrkjiUycZQ8G4+fJUc0zglevPke5IQDeIHJ8roQ5UetJn3x5vuD2KRd71KE6Chau0qJYAi6/FL7OvvpptG3WUQd5s2+3uK9EZ9G3nWKNn20ZxPRwn+UVAOIEKnKZ3mBebv2dFWhaV6xYkk4nFQeiS5xmBmTptxN2xNSxE90CL4BOCwhrMUX/EOVv3BsWX9sbVmHQ1+wbCH2gGd914/vdFDc6CVb5ALT8fuSlmBFvC8AhUzjGfOuNRwRTIBXVYpcSdc6ImrKbQItQ0duHQLkzMicMmVY3Hjtv8QWHaOqKHKlyd85ObQFYXNeQF2jq6RmNeDDJ5jEDLlaaMvPWuu6aNYKb8PWe4CxnhGn90/wKoSq7JnjnXS/HMbDo1IhXR5Io0r8WeqVfXpgrTLp4ywa+2A30b1c2lNvXQSgmVQ73Hm1d29H9qDBR6ro4GAeVEsvOKYp9lGYmCaThcIcyxMqYHgSQXhkY57dy+IyjZS5JAvG5XmtyfSHc4ILft1ksx+q+U7+v9w6mgrhP7Z+VJfnp68vXl6+fPP6/csXCcJfVPnM+EFlnwTeNOTr0AfKvxVwyAJ43/RMIEDwesvZTdloB1cnlWK7cs1P4td8yu6ZRoxKsboMntHrp+2mOE8QGq/KShAei+BOg6sPnHi5E5TnOdnF5UdbhL77IyrM+w4vSd1ksz/KnQn/mczxzaYSpZznc/zXQ7zPwq1CR7uGYSG4ornwfUeK5fKS/aA8xFwCr7SYBGhFl6QRxVVZla4hejTY2jGaGGjDVUmXTsaX9JITdTfTasV4F5j5OdtUy4EFzhFtCeDnqBXgLqjyDmtiq6pDb/QMOjDJvXRyaYQFSdnRXDjvKcdNpotZydV1y/iHC1XDz4Q3223a8yWfzVFfLoUG01Uw7m209UuSJznM8+EJdmOXoHsIZivwcZ4/fUpHI5JytJuI6Fwl49s1oRfg0JgyNVH9EBWxke5wR0cV6sipdrqAaZYtIxVo4kmzfMozOoX93NVQp0Jz3PhsI9jKPqyRifHwWDPgvRk8Q0yTTfuqenEU/qIREpINVXvesoUXe/7m+7cvX529GI3Mr+02lTOAXufw73Z7v0MzMs+Fwj8gi/z+tK6rUm0N52SVXVH8+vpHRkn2Vzecqlg4TOTPcpSgALqw7BcEme8LWlwT/rbaXJe0SRDmix4W4ljROE7WPzPaetOCMbQ86l8yVaC9Dif7WBwZ3ygqcrprscmBoNzEp0BjTj4SDq71EQfUUC7ru0ZWhcuBVQR+DZdPXbFO5erwQUdI/OU1RQqJ1ndNxI+eCU5Qtuz6wDHaq67PZq47TAowyfcNFZMgVpwZkn22DDMOwJzMnkFTgvxoi926G1k3ZgizXQyCHzIM9AQZKBoGK7ahS8Xs4XNyRGz8td75a4Qdea6KxoI7cIAVOzrk3KC6dBjZwt5R3UNkqZsgIPMgOeJHidcyEVifhVOVm6kjW1/2tb515b+rSHNB1HZ/QURPR4DKag84m849iS9s4VQkxdeUoO029d4WSzBNpvoHMiufUVX16XJJlmm4JryvHnWdtXNaVWEjAhOvFWc3adAtpiOLxWc6vK9ZI5TGTXeZfAnVdd7apMpQbLwmxfKBY78dqUsW2PYF3Do+TmoqK3J7TR89I2bik68pdU0iOeqYdBfLZcfyUCtnfPrD0Wjhq/y+6V5DSRG5p4426xL8eju5+ydVB1OkLWuPkbvotsvgf3hOIHvBZdou3rNzAhNyzwfylFUuEG4W+X3z8TpL1kLU2bNnt7e349t/GzN+/ezL4+PjZ83H6wR/WoObdTfJye9+97tn8DXBn6qSfuhPJL8m+FO8nL98/0om+69ntLgh2hf7001Fm1664OuzZIc3i/zZv0qh6F+fXeNqkSfv6bXs/KfqZYIX6p02UjKvW/mnXhh+7eMjisi+Bf4nPkIFQ1MogcnjeMoADVphkm8kXzcIjKy9CadtlMrVoie+6fBEHvj0VXrXKU0ETmkakHO9VySD+UIcWc6Grl4XXN81NrA0tJjGCV0STvhXEMf75dIKaQrrQVFzrhPBx6VsTz/SlE3rcx+59ZHtdig8CSAof2KA5seELoq62VQg2Gr4dCHGZxApmSwzRxQJWwDyixiXy/ZEsN2mapO6WaSdHor3DxYo3kEgosjiMUWwY9V1dWcWNsJ0YmhVtxKZedTXE+wmM1SR28HV4fTIXrRQ7haZtkOd3F+h8Yaf1wtFrVBGtQ2ezU1s66CKdqcH+NH9jY8NX2ufGvkYIGhcEXkicGay/5n4lyB6H14+JM7FZv6yEEWu9YwalheCLMam8LLLgX26HvYHGYhp3Ajj9UXaLGZijgnKesw0QnCrB/1pgnJc95luOX2eTEEhnnsH+YWucuRgD7PRKPDj6p599vjaydyhu50PJlORhXD0LZEdPVHWT+3dIJn2GOkQlBGFCt0R4p9crsnARE42YSEGy1KppsB4clDQO6OPap44/keuSJUkONC4tZ58D/n9BbFgH+VWSg6zncYcWDlH9yLnR0mWHKnQwSxvFnLfZNOOZTRTWuyYzTVYGkSNsbvD32/NDThDmts1ixmdT/g0ZhjNsZBkhFbXVDXDUhOzyia/zLUjMokPd+0gD/tlyNHgo+d0/KJo1s+Lhky164QLHaJM02Wql2A1WVAxTUrzM8mSBAbHce/okh13u6DRqlUOx1IwCxxBgob1QpzcLVKBk1p/ThCO0dfrB9l6kAfrqYKzcp+mRlVa6fN0gnCEO3S2mn2KnNUipQabMczTl1pvdx8XefLfCZjiPWdLAuZ4rUx7t7CSFfHT5Hn+cdFVM3wNehIh+dQdFWsiysUAEAEHieRWNqJhSRfVZkkGpBRrwgfJV5zdNoRbC4Lme7bcVCQZSEb3mrG6+6Wkgzu24YOi1U6Onyid4/UC3/Qfpx+Mis8ATwjMrnI+UdZA9SLlUibhrohjT9+tVFMizIwjg1zf+WLhCvKyDJlCnizgcxX7vOcA7oiCnu68j7e67VOyiqkaAuke4ojqBYfqSe1VQ9EkIvf0UMWx6/thCANvy126XCB8tX8kMTPA8NGxLLunEopL6ISzSgPEm7FmuHSM03PmnxDyPHdF7CkfF0IUi7V6k97fsCXJElYTmuxQxiOOlbhLjNFUpG7NLcJ+Iecdk/OOOfMON/nxpPl9YQ6WjTlYbnptc41uZeMJAsWsmXtt9mSsjRVfyz0TUvLAN/wB+3wDj6m6fWqOBjpL6O0TkZDjh4lWC5MGRR6CwOB7e0UTuzNqDfHy/camAnVsfOOiqNlJu9W56Q+qr8cH7MDWOYl/SetikmJgwtwpJi5pHlA7QpYL3C7y2H3WjxA8S/47fv++ubu5YtX79zGwuOQ9XF/YNMkR2eH3i/x2kSbhLpkg/Fx9iUAoJQh/WuT3O3y2yMNCnfg3F4LVNVkmk/1Uz2QtX706ff7d+1cvLy7PXrw/+/PZ68uLBM1Ho/RaVqRury9izirD4fViNLpehJ4T8lR1uYgcQz4tZgqnZq6uXhyFrY11p1n9TKU5yfOc+uHp0yKns+M5Gsu2D/Mcel/HvpgW8HbMNzQtxuuCLiutbcAcZfaNC67HkRMGhJrbN1zmx5Py92086uExhNw/W8wnpeF3xSQtcjYrPyMtu91uhz/8CuHBcMoxhTvSXMrFox6e+Pdql3K03bKxA7C1f/+P4XSBfBabZ5BuNHL/tEWNRsPgzTiYzo1g9cubG7IsCwHCtp7bGpAw/4XZO/n6Ek4OTRjuFBqBWU6WfHiMcD+eY+guaa4RY4vtuHPHcMi1HVTIcggIOSSz94v5dvtXMS6bl1QbSchpkqLRaHixkDwvCu/G8PAEgdW8FnY+LWDBbrep/g386vT1N+9enZ6DxP316auLswQp9lHkZFbOcZMXo1Fh3dMnxXabqk+5lGeVDAFkTGElcbk7u2tKtuI4z3NTBiqUWvpejny2wXpNZWynqTVLu8qHJ3iRH08WrdyyUMb8xWwxN4sxz3OG7qt8eKxt8avttr+KXbPdQpemAl8uwBaya6dlIT1ieHg6DHRsPz1kcMns+WKur1ztXhvJricfwTMFwKf7mqmhw2XORiMyY6qo8rFFtdLi8ETLhqUrG5artJw1bh9TdF/kw2Mp+9XAbxt8gnSPF1M5wKVlvF6N0MvzVsXxAGmwfbMFwueL/L4uaDY8xnVBwYNQ/5al6J+ELvWvBQAg6gfweFY/ldez+r2p9Y8lu1UFl3Sxtj/aOuSTrUU+mHrkb6cm+Vi2JbGNys5J09gfqlLORCFI+8vWpR5NZepJ16Ye2uqa27Im9odpIzzYVsKTqhJ+mpaKQr7b4Zetbc23xc0N4d+QRmw4eQ72qAnCb8MEykw+Qfj0gXt7ovwjZnN9Sf6RcF4uSZPfR/HYrzZltVRVRMQOSYP6mGqFOQPk/aadu1Se58F3JU2g+xMEFwH3hLpWtfBddWU0gUcrUumpSuh/m9H2/C60LuT1rzppmrMShLtZlddwztTQqnDQrKDv5Slzz/6+bwNKh+ddUc/3YpLbiPZSf75pBLvREJZouzW+A2ogTDpFlAlZ4MWYBHWz0TIr45CFCh94RQZXoOi5Ioti0xA9uOM/XgzKBpTRUOxyUNDlgLLBAkhRL/lgXTSDK0LooKnJAryKx08QPgk98h+3vwL52mjHGDKlysAIoM6dPsJhTzgdYUZ4eIILT8DKh8e7iW8QLtOnqGPxK1m4VwGyO5AfwlN2r+6Zb0+///7s/P2rN6cvzs4HC3ZTV0SQpQpP1OlcyYmUvSn+yMpl6lG6QyAVFHmP9o8itENj5frl7pLxsRcPj71wmmEp1UO9KspKDa9P486Dqi1SZJkKk+L6m41oyiXR8lFoTl3m3Kwxl++kxKuFoHso65tNwZdk6RZClelCu2LhuFx4NLXfViv4uOvABrorrBctwhCq+KkNRE3QH56e2N3xzSKfJUUlEoUBylmV4OSGiCLBSbMuVyKZ4xeL/L6oRCy8ORkXlfiO3O2wzh1PtBC8glSy5HgS+QWSQK3xNPBJJtrhv++zWWrr7fDKX8b/jA+Zwlg/M3Z9HeuafYzDOb11yqHy0CnUSD0vqgp8E9h4talktxlFZYfH+NZync/757NrVuNAP6cEs/FSzy1JHC6NNY9Hc2evpZ3I9jpuumQWXB6v5egpxnjsHO232+QDuZPyRTLMcz4aycdNDQ8d02jZd+8p4zdFVf5MviN3KR3XrE4hMnuSyLLfLHrNv0ROnWUwEX94ejIapdRIogKfIFwe5eRI0ryD3wwfDx1SJeHM10m0xBX5vV3ZhdeHOceFGc28xMVOyRPw/Wv9OnJzm+DWnc1ga0jCtV5pkOQ54A0GG/GU5omyQMqScWK9EZIlE4lc8d3+4eieDyHZMX6xmPE5UhA54ijnpjPEkfLL8SZpZ4KHhyCG7jtNTRn4gkj5Ps4lTccq8/odDsbc6yptU0OUFU1CmkWiTVDk76ImiTUrMWxhZ7nf9wvfFuLPn8cSch+TKWgpyp/DC70ebwC/cYM3fPz6zeuzzJotm7ffXn7/yr51EWleLaZiDC57Jb2+XJfNV/Kg1Thm9RdkseGluNNh0QD69DUTF8VK3S+mAicQl8TZoxyDS+u5f83za77dSnm7lhui9mQQUwXPkgqUJcmE5tdcoYETLr5iyztzTcDNsfT/4DLnkyW712yCRW76YGsfCDYwvTlYi5vKEwtKWm+ElFo2sjOu4AaCPX2KeV7iEtiABkXFe0ja3a7LiqR8mOelUWZIOi45bvLCjiVotDmh6VueUrTdtpdQKuh6m3J5wW6IWJf0Ogyq/sPp+euXr7/JTJNKeg2gRING8LKuyXLQsBsy0HdVg7TRQdSzZ8+uxwv2jF4/a/RI/sunpkGS6Ta7VUmLqrpTNgTmvLPJDZ2TjYcqvfFsTTYeqvTOMfW2I4qQnYEXl399dRadgu8+yxS8ULdIXvhGKe6mROP/pASNBS9vUmTRg5KJQaYAA5X0NW83zNFoyVMxO5lLViT/AuwXJDvlyFebtoiHw2NM5T/KvJJEzCsttAxHk+SJZL5sNKJTkQ9F9iR5op6F8g6jrUXZaER3gFCfpWrOPDw7NrQpVmQA12sDAFCEi+7ksLmRqOwJ2slxbIcR0GgzeXZxx/DrhbVrPGwodbi+PeMJMLoJws661i1Sbdk0ZCkP5sVARcsb6EiuSUvsu/M40/tqsd16L37+LFPw3blkgkuexub/+dnFm3fnz8/eS6LC7vvqs3ffucYeUDQ93IcGq2Dw7vyV6cmHJ0rSmmRGvDrIp5osBFkODNU62tOh0zAJlZ+dlnY3SR+0LWIFck5+2pRcnv8H0BGgj8aDayYGhSQMHOvuakDJS9GBZPpexXd10TSmzZd804hvxU0VPTWQ28GrReeUECmhF0lJFvHusCJgmfSV8fVBZbzjve34+aAC7LzsL+grXdAu/X6B8LcP2bwetF7iPk6CqZUaQUyxU0wFZ5ZSw8yYYs3zqxKwMTM5ew6m4aC5pNV9r3rlzODE+WvigTkzPdIDINPBMHy7QPjdP58gtcNbir7+f4AitUdZkn7+55Mk+b2l56t/Pj3uPmTp+mmRf6RpyXFypWzrEtxiHbwErAMVidl+32H7/dz57tT3p8qNUJci/NdqrLBidi0oQFtKU8lSwBw1+67SMAI/VHMnyQ9VFHQhgrSrcs93c8c88U8LP0RtJcD875s97ExuX90NS5sfKtNCUFAXFSfF8k4pqpU2ezx4uRrcsc2AErm1LRakaeT5Z8FubhgdLEtOFqL8SJpBs1msB0UzeH39cgU68NfXXzM+WHF2MygGVfHznVGQ30CNeKBsZQfPoShNhtxkSbGUB3/LV29Lsb6AyL8tmFPEEOeeXqtCMoJ1VwNShun2C2d8wejr5dIZlD/CoJx9KhshGfCF2OEvqrkOthk1aDGBO9VfkPh/WASCg7qWWBqXiQ2vcrHDPx5w52LwHPholPI8KW9qwsHxRSvA4SMbjVIGJ2E0idzSYNq5p9GYjyWjl7y8viYcbmk4xColSwWnsv+yZs/e9toWfiEKLtJyaTeycimFoQ2vVLRs3RlHyROkVu8PC4S/+wUWKJ0mMlkuxLU5J2p2Njnfa11yUIPO6PKg5sBLv3ovif/Jb/8fP0/7OSkaRj9Ho7Ve9pHD+MXnaQYEsfwsQwfs7rDBg0ptQng6Spy2/fUX3ZZG1mFskpbj5tetv3O2EaQ5Jwt2TcufyW80Y/EAyLQlw5PXS3/5f7qXQO3bQASmw9nUb9BLpH6gl3CpLf4e6Kci2k+F7adi3KzZplqeyp1avipx8au77jdjiD0dhwd+I9rv3muvh8VDPfzPXa0K4/OfOgfp/4Qe+kdPNad/eP2AkoBLlvtoJQAwamWw9IoVSzUF6kKsLSlQLiANKnoU6so/hBrZ3Q/TUj5ES0OLulkz8WhyQO+v17MVJRVBT5Kj1Ctc0aZo1zYtsU9A/HabJEiLKgp95B/VhLZHP28Dmt+sAf+I7t/8A6j/rXq+6qXdQciHUrgyldEHwFoH6TcoEQVdrBnP6WOViAvOqipVuVsep56BsZmKnIabV1PvaXY8l+xUl2DfnswBZs1r9KL276zrOk9qXt4U/C7Bq4dGsy54cdPkZLuNW1Oui6j9i5M35vERwBHlwS0d5FbQSB46lypwRmxAXB+XRKCpmB3PM4vbpCHnOthHn7G+bCbmurrZvA/e1gNx/kDuml4AVxc73SEBHYbM3Kqb1nWgRV9BSH77fVn7pokKHtdY4DxLwOrGBocjMQuWcpUmq01VgcEIZIfIRYDesi4ae8mNtltTkL0BRV5JrU/N/U4701gU/daBJufKLYDMSjA+L7zoLlmCEJsVTvSWEzTPG4XeL1MP87wBKt2q9cjdLxhtNjdkmRlIvWPMbWTmmjWA9tpkTGHOfKxj+iLgG41hGUpblruog3e1NoQweiABQWOSxDEtzo8ntL0npqbxPCczOp9c1ynHN3UqMEdo147mde2gynRVhn+jA/i/l/RjUZXLgZ08kJmtBkA68KOj5Ek2OKMLtqGCcLIcWA2aSjQ2ZV2uyUCpLAY35fUajC0LOiCfBC9AzViM/0ZN4rNPxU1dkcw8y+4WqsAmG6jz7yAfzMz3weB+oPn/EzzgWva7ZNngybNl0ayvWMGXkl2aSZcNnsip+GSww5Ey3CwD60ObDV6Y9zZ0xWCH8eD3vx+IW6UrLZpYcUQUZfUsK2V5TnHfEs5ewDenPJN/PlG/1Mry+QhB3TE7dKygBMfg1Roqq4qGpHUahpD7C70s4aFixfK5fQER6ysi2l/DPK/rX05b0fZORZpGf74txZptxMBQMmB84BJiGrMuPpJBMaDFDVkOFD2DhgjVLjJuZ4Wk1xT2y4ltywM1+CKg5krfjgt2TcSa8DgZbjs+GymxzukjZ+GM5uchxnbEY0kJBsjMhM83QnaRPUCIXLZtyL4I4OShBMiCoGpd0v6KLZv3u+LwFflLCR0P3lAi34o1GaxYVbHbkl6ri+srMtBXJ8us7UGXx+LehdlplupY58Wv7mG1JShSYf1r0I1C9T2Tv0znB5yuC0yi6VPBvNRTG8frV84CPfIggQBHGxSDpiqatSYm6XTQMJwIQUfCPvZ4qu7VpvS3JAEHCH+3TJ4cuXUeJX9LdrIFCthET4TBE1v9kzHs69qGRxsFsZWbYlA2gyc1BEN5onw+2EoQqm0owdawhKvGTUP0pjx2J87Qa+9opETIzltVQ/D+140ZFCEHbsBodQd7JRGSUtMcOb0UxQmauOtSCm72EQtHjL6pA6wzst0KIHhKRqOh+XmUPEuyIRmN9Av1J4P3R/ohSTLSFnxVu6EQXa5ufo9vijq9qgGofFqm9ztM8L35mIkdytRLY8I4pC7fScV2S31uMxpRKwBQVwAAk/cWemQh62wpva0d817Mc/cEQxBm3gvhnSuGoWn88MRKwpFjgGTmMwrHgPkwz8WMztt8+sdxS9j7ek/c8gWji0JoE4fZHLtno+e150RiPJCnZGYenupzdpvnk+4Fz0eQIBIefmU3C9mMOaZOlWd+lXVZk/QvKcLfbCLIpsNjFRnByX/h5n8ulGXoe/j7Y2riPejoVFLczN5uvOPgZR3gPtGpf8LRr/Vg71KioODUuQgL98kxhh0o/DI4l7ytUzFuCMQ5bTC1P1E7hvIkPqabmyvC36zMvBzK02X4sjtfuOxw2sqBUKewzzM+9+oZktT7iKmX1Kbd2XmVKhdzLOAPyqL94891c+oN1oR1Vw5Sk4+E30Uxc2d0Lod8Rue7R/d94GAxEKm+IShXaTsKZpaHC1IOW5E76czx2CbEDI1GQ+4f+Sexwl1XGDMl2kSYoQgXkKPKg1F1hqrsjKr3EXMvaWRUlWaB2WZ1iEa4sZ+7HydONzlNKWSXuHTW9Vyue/8N5rhBO7iycZZDONGAxA+HKS6Z1Vg6c8IoLVc6yHCrtjxAWdWW83DEMS/tdptG3ubrOg3pQwbG2kt5gMLrIKXr4EU9bggvwRdIeeFovej5nj7tBnMw42M62Ayk6V0FFqSion2qU4Gj/IHYdLso4KqziCJNgYpCVviH44O0jmG2wzWQdvHpSf/ZRubvtTceL/eOh+5ksbY6+TYAk3jEhLbZHp7PblI7nd2Xdja3tNjJ7Kb7bD32tddjrWbxbR3MMstwhd1sSLi/EB91q1DpZ3QOv3eOdHDqinj5zGrDP3lysVMwR/c8N6JjTrW0lQr4BOEM9mYd7s1KgSO+Dm413vTNHje6k4ft1XRdUhX8wzd16zMJh40PUnSBHOeMiQvFCQCSHF7+qeVl7UsT0j1FHexSzYy6tWNqPDWfJUcxGSpQrCNnISEPEUt4G83UE3bkzjM8QVmSYOYPpoiMiEI21SPCFLyNgoiVdA1PYEhYKyTzoyRNjtj476ykafLsWYKOEpRkXEeqPfVYo+sBqibMdBajdZ7NuK6TwvPOjg+0/Sh5liZHZVCp3UmHx+gIgsa7clNKg5MJHKjCMaG56L3+oWhK/UztEvxzbeIj/1kSuEOatlGCMu8bRTtkOOs0mSZH1EmZJOgoptgwW/k0+RcnAHPafoCsmq++qGFWv6lbfvF3/7hhpZqwB1q2Q9omPEsc1vC9V1IsSLTFDH32r/9+/OwaJ/+duO/+7fTZdYmTzHv55b/LhF/4755DQuzW/me3diDFLfkryDBxM3y7J8PfUlnpv375X261f0Pq5e98Wv4Dih65Rb9yi16SSE+0ad+5aWVGp8IjVeFx4p7vvnYyJMmRbIa6y1Lzut1/8ANzWhcxUWWoWfhtnQoVZlmPsEHiUibqP9f5s/87+79/e5ai6ST/l/nRs3YifeWpKZQ75M916zWp7mOTBAr6SRWUT0eyEPwn9aifvnnoInrDK7P1c3JTlFRukVETg5BT90lS+tLvDeD7FBXMbAyaO78WZTQ1rglRlof6xnGaoJ4v/5KgqVxy53U6m+P7HcraJyMvNMTh4x2Ec29TcelXaHb3u4m5te40YpogtGT3bT1tSXIOKg/leNZR0iJEkAhNZk87uENlR0SWgt+9NjJcWF1MEja61aAIfY27m/QO7ET13GwOZ8vosKVyQFUM1LTtPrvd6zARYa5niQUy6nza9y1N0AQpcotabDhR829f/WqdmVbGSrTgSG6RrTFDQ97K40eTDo91cdSBoOjrFJDEukWcIITTVj223UaVH384hvxyJ8/1KpCypBTjuiMeWbBq2L6qw0nTatm1FVBI+CSJ6PjPbmpxpzT4G14N9Mbn3Ti2vLS10LHVHiVPnNCZXlcT5Vb7sk5hJ3AW+veF4OUnIyDGFrubwmODWg1C8t6pPbHTyAwOrPN9yxjSRGTfeCebs5dppzATR6GnxKnKExtwJVKqwbEyRdKcox2ZvZKS0jx/BULRXpYYE53zVARcQe9HP9UImX1IC8l+7QZ64qAGsUjHmZ3vT7Gdr9N6FrSe5wxp6fidbDou5F+uLy8D/XGpydBmML5A2qDtNgWEzCafNXOEdfDTwgRzkJ+KWNeqNR1p2v2u5ZeWqUjWNYz3E5LsIhgGC+FpROrulMA8GLuZgdABU5/kmYH6QebHROH9dOPfqqUMrYI17hsbJwY2RN1GTVp8HymC/uHpyTQFZF+wIgJ9oPtdr2rTESx4hiQZAe+uuja+XbEdfyJmbJ6f5Ll3BintQaCU/NKRGkqEe3a2Z63LXRgoxWOIvUZ67Tg55lSdiDl+vVF85xgXJnZHamW2sFZrsGWNw+SBLahf9XBotxefhBFzmidnBntAgwSOn5jj0Q++Lb2r7PuGs02dk+1WCSg/RlJueAXReolj5/VdaHv3NnZCFMpPKZUJfqhVlMdW4P/jo8v4sVPGF48uQ6+hN7S6GxRXDas2gtgL5QbuTmGPdG1ymrFvoAVgDk8SIEUugL/uVV2rqwgzjNqUnXCjVd3w6sLoS3hOsdfnbTiGVXmdM22aW1XstnVnGB5rxHbtZKoiJad/EvFIuXVd3XWlD9dnAkojn+qCLi+cWZJ6tbiEeTQrfURdI3XF91NsQEy4incqSyowsdldBUb71p76d0gXTCuv5BBf5Me6xe0NO+wEm+1MmAqUHOAW8IOxCiNjyuBiXU0dgQwSyS4UdKDMyA7z6zp3T4+6MSf9HqU47Mn9PUi6UCK2A4TfAcR0AOl0gJuuD+vC38TaMFnKLmYMaCy6Z9RS81gVrLtYqDPd8DgsKWY56dwDHjsH2DTl+f0OgQgPWtiMBNpRFonQ3B3GoHpH96fg/QIaRiPqqzunzvSwb1VLOoPvd6tqB5Gjm3XnGEDRCecODvPuDuRXuwfgdRJcuKZUX7YeB7u9vVAxa/HtJjUhFMp8NseF/KdxDmif6pRiv1zA58IVXuTpJme4yinmsRUkyazwBu3rqUbKJHLeTpjSxZZKfFygrDC/dgi/3WizCbjrKo2GvjBll1WKcCH/+SmC0dfIdeFchO6bNZ0J4zpXun1tSVJSHd6kNNLSxhJR+PWcXhdyaYMdsq6q0ZUdygzaIVRu/Q4TQBh65E9RU44h2SHsFa91/V4Fp5vtVp1dgUEo4zK5CUPSYkzZK7IS7CPhzUv6jlepgH3VpcpVRxnytOgh0K6fZ/kFd+a9s4DbqybHqHFG53sG2O346GDjol3Hq5SjYZ6X0+8kyVkLteBYuCkWAXyzb2xlx2SFPqT4m9+0yxvc7O+akl6bxN6UzICkAxvqFdMzxbWa9v/7/xJooDIaa4n7oayWzwu+lDK22sP20SlLLT3Gd04A3fVRbYy17hF0RJi/xmddlw3WpyRYxCbHc3ZzU9BlIyctdcZYzuAWQrN977mDPEvQ9I91appdlZRwkCJ1m5uU2tX9nSczKPar1wt1K2OdbaPU/TM8QZ2l86iefpDT4Sb/S62XNd7k9tBjiGlwlTfjqtD4i3iRt15hRQVjY1KCoYxeJGRpeATMYNh76n1jscHucsML2zn8gZGo+0eC47o7EryPWZseMvuOMc6pEMJldCT62MHeKQlqB7X+qO825FlNTjtHF/icknFJ/w7BTx+QTsbvFbyOclvMCdYzj8uZt1OWeu4rNUZ6NkiaD5gND434Iue2Ez1R/JqoAhRxsDd1BspBc9YIQTwn2hkKN/0yH7Wipgue6e0qfNywGxKV6Fc66WhEVylFcD8NtnGYoum9KxRnZGU6MDTK0SarmEkZi4F8KwCbtjVCLVKCcJOXEB02RZNhM14ySibtKxPOrhmDufQElNIbbfpNV+kGGXMGNoNHqwfXm/FupxDuCbqn+b2CMiE7C8Uq6WlGI10xwAqVOhQ6Go24cvAvkQ/dqvd3dbRvAet3KceWszlOMwghDBPATqBsNt9lLur2rxmkBwemPX/gnjWJG7wBJbgzOlVepBThRV7Z0Vmo0Wlfqex1vtCjo2mqwWZRjkcN0cs2+mf/0LCeoVmMRrrW0Sht8qodmkYNTeUNjUEnZsHQgK02xxvVU5j7oxMODt1lQVd2U+xSgTd4ITmEZAZuclzn2pDTZpg4glxth7wKDmAsPH1JSqsDTl8bffhS8pop3q1s2vK5DfR9Fm63FFeY4xrXtTydHVCn2SHa2YXcbgXZvOuL7DC8PMIufH2FLc2Q/9GzoiHyvOnvF9YLQvicXxYQvAptjHX940VB5VZjZaDR6HjYLtTpWZ3+mEY2HScyqgo1Ywq4qFNuCp3aX1LG5qmAToJdSB6J3X1N7Nu0+ZTu3xXFvhEUnV1RHk1iMR4eVGumKc21ViVEyCrp9ZkCjtL6Flln6/3kooNfbwq+NC5Vyrfkb4lFKDAoG0/+lgxU9WQ5WBVVQxKExvS6r2KAhzYXsTtAVnZ2/I9aaYHCeM2hABVM09aXeDbHPFdmxJOJMvhuLeq4syrUsuwxsofjo/bb6Bifnmy3Q+7Za5lcX9SeDyCa8NxPuOuE0+/Km33nzYiEykkhuKM07eqP1SVMKhAmHW3VnrL2iokmdG6ga1FaSZm2qylrc7mGg8I36nd1xq6tNBaOrjKi6YuajTjcw1MmkcDwMupFNxqRjqO9xYJzve0ndMbnuZixubpthEdQb8QIfUAx2D0betka6OTWm0TucoXfuLgxY4nui1k5z1nPwKmQtchISSUuot0cXXqdI4RlRT1GgkKDLvi9O2XjVUmXbzXqgFJayO1Qvn3DzyFvquUqjzY3W4+Gks5MpS5Ogg4L2HeZalYxOMup+52x4ZmyTrhjNTzQsY/gXfIM/bHJCZL4cUcAF48UwMtVujHmzMQ7ugkTuEWeoSfs6OgfJ3qT0GT7L9bjypo0ubRaZA3hIWuQEFmjPUWh6b0+4GXDExweCLPZHNvzYHaMe3QD2f1ul7XlHP+acrRVRSqMW/B2u6yRPHhg0U6R6d7auD3ZOrW2L3Xje6ngY4vd4TbrV3VPe79KVloZfKL0scHe6DprwsbYceeUbye+0OrcxBjLd2efFo70aidW69m18nfJdNidL6KdL9ut9b114FvQaJS0Sg/HedlVtbV10pVnSayuhLfbuoa7X756wKjzvfJZeoT/hszwgN+GTKJ4weMcL7RrTvyKErrja85uVJjwVk9iOvRkKmbm4emX84hR46J7eWRqYCsTbRKod82IfIffiAhMdFuRPLMHDNfEY3lMlaORU6e9DnSM8o/nqsZIE5vySkq3MUuioq8+4yX55XQ2z7w+PLzp41VZCcKjm+wQnGVDo6d2MGN3sSGxDxIQsnfVu3ZjA1su4OaQ3m5I3mbH5GbXrnBc5szueqXa9dpXxgwMKip1sbKaBtmbtod3t3I00kXD7sY6uxs7aHfzfaGLQ9o+E/Nf3/ii0/jgSrUZb6gKIyeliH9Yh8zmwP6aXvZnPdqA9K5P4SOB5eQx4TVbklTbukGpLepjOy03K8+0z9Ti4QrEguGZ+TrTE14zeiXfKzeBarUHk7RVPfRHo+UtciDFH1cpxwJh/osgSNVGYHEBTcJUhRHhK6dHFu5kjR6ZICrxSqkE5X9JggFFT261m6oyJihPT7yLKXI7WErBDk4SzSqleDZHoN0TEN1QHgc36UybDEOZaI4wM1/ud3INOA+F+9CYhyRBeAMPtewxhgvc4FJTN/YY7cbpX30+JbeDSilhm1W6kRTKUwVoTPdM3fZyFjdd54zaczp2/ZBp4Ies7beWhSiM9ZaaVnlpbHwM5kShmfFqIzacXJh2NI8SHCw45APyg1+Jiyr5sDzxuSSYjSAcYP1hpD5LvUq8eUTNKoP1OP31FLTyyCOoaDN9RkoWD3lBd+kwWT4jFa4U8qhxcSTRz0nNQV7+dejgb164kJl7dLtr5UzoO0of5CT9T4ArCHnYI9r126AZeBvbtG+by5KvN8oi/SjG0mKSwWoVB6ckN7W4e0Oru8T4ffgTEEIblqs0Karb4q6Rp0kBkSO5vZF4ejLhf8hPJkY3Bngrhfzz9ARUT8wH9YXzJ+ug+SL+9CnAeSqbpxZQ7oqT4sOEP31q5dGopM7JcrMgqb/Fa8cxNWs1YpKew8qTG5SucosyH+VvLOAPwhpSx3zTj1iM3+ufyxcy3W6HTRX3O1Xa/c5mvt/twCROXcFzpHbg9YE7MAbzv3/sPuwMTa6V1e9B1a4K3OhXVdGIt4VYv6RL8imvzIFKNTtffO5T///umf+7Z/5P2zM9BJHmf8am+A/H8FGhDtINrzLHm6tfJ+Oc9xzQAgWwXoh1ZrHVHT42DV8YVD4PS3352ENuGHKDq2Bi6nxLf/H59k77KSrtVPdU+1Hv5lrn4q0FuUHsOe23mjNdiOtSdLeKwRK2WsJkcA9BUz3F3d3KjAIeyO4c7AZJliQG60SmVwoL4SBaG906sfJNW695g6UwEsg2E+KqEW7r4GKVerN2u/VuV5V2ifZduIIS3DyMRq3XiMlnb2ZVvbWpsm5rq72KjHzhyyTQaoOQaM2qu+BoAVj40RFF5Sod3tYKXxDwESMAicqvB1P5L9Ak15ImSL5SxIOYQ5WYIxPJHyYVvNQupU64h3AosJur81WXYkf8JtAa6kl4q6AufIFsNHpbp3LwZUN4Dg0C/MoOxJEPXegCZfCZmLvATTs0Gg3TodnChzmgd8qfaDRq32+3NwpTWD5gm8RpyJVzJZIwYM/edboKsUnATF670MFvfc0jBSYHXXPl+smpK9FWccdHo091ysP5MxPzPEQYn5I+LJDkiOxQpv5gbaagFER5npNpu1coJKL2jvuw63Y2K+e5LIpOeWZKaG/YhQsAuNMVwxUhLrF2jH6/VxRuIziUzal2WjRCsLmTe8E2VxV5wYQViBfGwoRiOSaOMerVKqWz43kEPUAKD1HMgBvw33egAxLjU07h1jvW7ftmhp0YO2V3MxrxYZ4/r1Maoepep5XnCIgHKtjgSpktSQF8oFuaRD0eBfOvQHxxoO3Q0ejEoG6YnrNmfACw7H2aHc/1hvl81TFEiHjY6hMLZwvStAB4eqTAATunjoPtp0NXmO3Hqf0FjtUw2W1xZytnIpHtNiWBGShWKM0d/zQSh+O6MOXpORB2gIUszY8xywUuc3U1nQ1PcG2OS5kUl6A39eNuwn7foUFZdfE/2LO2oaGcmBB0JseMzXGTf5KTm88R3uT89+0BfUpn/EiD2sKJXC4Eqwpo9BG7XKXNaLQZjTqdvnFSb0xXKxftl6tUnlEL1JLGj/Ivd+YkrxLc74IURzt2dGTCc+juOXa6h/ndw3c73b0Y/PfVUXrsptEmbDfKlEI51cCHbrcGXiCkC3/qZEeu3r/0Lvd7C/CyOzap+GKVlvhYMj4rMGqCjx341GnXbvp+hzKbdhjMzOmlmZImzRQmqawos98cOGF3RbhW4KjPWgEbz0W+D9ZOTxsbi5fMjufTNBWOe6nr2SU/2xWcptRJRlHmft2lMPDejsQDnDkd2pqCJT6f52duvIQZn0OD92ITuuoxKT5ASWKeE2c/I95+ZnvUdrKz+iPTSiAwgWJ2aaoF3llvdMbmrm3GjM3bVafm7ge50p3XgaEJxyXa6dFlzqbHNcSfupdy2IdQuJBYJcPs6Egp4xSf+aRqA7Rcn68wy1eK0aiBmho0Tf16CnwuX0O5+Zco63wGNsyOjlB75+z6ydh+/hC94AxtHamdDWQ0SgFe+XLl+0jiYzC9Rdg5lJwfWri9LqXzXAtWTjEvAzudAWnNbW7BrceTS2V9b1dd6AkXDFVFELSvZ/ZXC1i+w6erWNiiVrnnl7XDrx/QQOoClFhv77A33KI3KH+gl9rk2+odGb8t+FIFWDMYDgU1oUAhTGmTG6i0RUFfkCL8FhNlSlqKPmTN3KFUHZoNqq/Y1MAnQcWgAqUa42HZlKn9pbJl6soXz/TJeh6ah0oKVTEH4EiUjW0bqCs0nlzZnDovtWZiQ593uyLt2uB70Qh0ttMgE5jznxhj846vu9bQvihEcQhgQ0Duj2l8SA2pmzhEA99QHTgUDgEbQcBnJI6jXPDrjYdXkH85jZR6nv5xo27c/7JJTxD+dpMKhFKKdlmkvyC1c3hxvdX0weVIdpoqDKUC7XbxsyYxZvybqgr61h/yiOANviE9M79FYPZKPD20vNOHS4uuiIcMtDerVLghM6I2JEyV7S40gsvQosR17TTf5H6zJBURZNBJr/brMj5N2HhpexDqPaXLl6JxwCMouPwwKsgnoZxdIt1xSE9osnCZi6lw7ONwkdOpV4vfAGRl7nI08i698jwv3Wdj9KQYF4RPPt9QRdYpXerFw5u0xAz712c8lg5NtMN7d2LYvfftKuUIZSlTt0OlUgsx/3orL4PrLryHt8puY+2mMy2mhZ020BUZGPM3FiStuwgsdaertNDd2JaIS6R1U6UuY/8cELhAPZtQ2A/72wWj/XDTgvnVP46dc2NzW4rFWrK3RdEQc+GaGcXeBN4qDdkb7jiCPF8X9JrYhFrRtt2CpnBPLAm3QFOGDg0UlBW48uzt8F6nOsxzME/DdjFNQuWWlOIfXNLuEHj2s84a5GrZZQIkvEMmGnOj54CNrImVY361jJgsp6IzLxU3YKE7V3xf3y87tDtsmG+fONCtK3WXjTZ0kh3yQNSZCP2nv4j6B+WDlnhwapzBzSaJRpoWNt416GOxStqTSn4OCYfLUmVo0Plq883RY/snQkUU/MkeRzoycuSVMtkDwDccE+D6eukz1Vz21+z3W4/0CPc27t2b9+TODLU5Gkof6+gq5JK/ZB/AUZl0/F1NJVPvCTzL1EkBZdx90jX9aZP6TrF710Pc+N70ghtRauJO9TYObZsCjTmRGwNJe+3RxRgCsC5EZ2oDgHtoJd+dBbu9CFGaNPCGbboJW7Gw7XiOyZiypdf7zF/8ZbWcdl+l1BkH5j6F4wD/C7BXop0QhW49aB4qvyB3Mgo1Gc3t3PReNjIjWPVNJnYR74iQ/+7bCmFj8e6nQ9racjzCuCLMeNlPf0x51FFb22K5IyU6g9TWMQ2elVACJ2NMnXGKvQ4GTD3tZ6J9a0tLR3lU3FcHZZUCzOGJFUwx2QcQSAKBluqry9y1+dIWcqYCBAJfdz9sq983vH5EsIlWxPE4Ipx2MeOedprlfHY8D+FajPSYkhmb9zjZw8zXGbXulYHqdYcMEHGr3eqbPoZvBJXyvkqNfhycgrECRtMJe7Hiyhg+g6mst3fbGU38GU3N4EztL6PqMfOXBi+61UPJ0brd1qpA3A5vtZf2OlwDoWIiJiK3F8gW3cFZ5YBWPRoFGEEtEJH32vPFSW3DU3n6VIo4C76QRbRzCEAhiEHFfbPyw+u8OMAa0QlDZrH+L+/qVjWojrXCR3FtQV2NMlCdOF7SNeElIOBdCF4Icn1nrBM5qQpRfiSvSvoBpsNGEpOXMa0gJwt2TT2lIAJPHyWY/llfHXv4rLM5tupHB8M1Xi3yoVWMt6C6y+yimBrcUlxD6M7WuURzhBUn5GcCTh7+G2BFHq0R+6sQEdZ4qkTHRZ1Yu81XnizaSQVcV4RxTFm23eVgG+hrWhgvDQNHgZGmTFsoSVmRodb9ytHh70XvkFJLcLiM1bNPzlRqGZ6voCF75xeaGJOc3O97bi11lPFL57OyBj7QiSreVaSje4rMof34i50LahEDUA2u2YGFZZFJC1W4IAtx8vad6zWsO2ZB3CcfPyq2VgxwlJX98/sdZtFuVeNNQ8Wgjl1gTgK/wGCwVUT8ktyTjqHG5S0z1iONZz4i1mTQFDfERLmnxQ0BYBl+lDyBgONPkiOmsBV2nYbm1gkVs3HDuOjRSXu5FMDr05NMRF6fZH7iccUWRUUk8yi4PAx7CkxZ776J26cyxaXnANoorLVN3li/z43y+2xfqZxVvjFoXvzOk/38ij3oz8pge1geJPdoH2b1zcqY15DdAdBfm9FIkzgapWXetL6ipbIAbfZDfxmzpQh6q6TUOMrOnZn0ZvVb47P2d2FkHIM4/8glVK6/1EUEQEHAhjcrFYrB4BzP5g7mogbu0NAejoUpGEE596PZ/W7CzDZK8eaz7JrvQA8JIGxWP0bw3yVDwd/Lf48MRfjrFcDu26vw7hAE+B7w/Hh0D7/jtF3MgzAWbjftdnsBOUIIGDM88izwqU4dKI3grkWZQOigkdrsqAPR8YdjFaOc4fbTrJPq6Ylnkpmx3oYeCgzSdkABiHgEUzQp8qqLmNlYs6GqRc40cs96lRa4isRZ+42nWRFMM4XWGd2FLBJd+zMjPvYc8U8MGqQzm813ko4ahGFwKVrsFXjxKq99oXctX/h4gvpEu27hIwNjOVgtyzwqkizwyuz8My2EMrxEc2OwsvAgBNf+qbnNMZujOUzIjzGhXNaC11IO71T1Ec1D/7i/g+2Hc4qbiPH7hm34woBBTZA8zgXvzO7kREwMC8IUsqkMYBJ2sS5XYhp7mR1HqqVHEPsoeI8eUaYRsp6eOLEVPctjiOf9KwBbv20BW191AFvNzWYUptWTGBQcPhhx5hzzoMk5gVdhA+3O58kbG4UeKoUJI29USt5oX6l6F3nVQksBK19oa51Xq3ShmmJwRj0bokndJbDeRyBuZlDkPK8PEUCq0UjTDALIpiOAbA7CHm12Ghg9Dg1rZkfTbUyztzE+RGkTQZjdBeaFv2Zi+ZNp0zW97MwqzHDjRlAI4GXrvEi5YnZmgqzUBGlfqezrfNVOECCI4jUajYZMDucazQ2z82fHstuhy1iHJhW5LhZ3cuI1046tamb7e6Fry5fu5Nn0TJ7VaKTbMxqlVV63k6dSk6f2Js9GT55NDLiW4QXa2W51jCcZcuAnOq3dPGL6bCIIt0re6g60M31N7VW39uoRtVeR2i2n/Pa3w93K+3C3XvXibtkk7/wky0IU2+29Q/fXq8A/GlSikEb27M+BCvCrPhVgPMK2smx4QUSxiAUfG54EhhCC8VBjHjOVOBUHFsiJ4CX5SPruPKN2GGTTkO5hx+0kzz4nBAfZpQj/tFISI0mT8zfvLs8uEoT/dJglZaViX5HW67qs2lhYDGB54R73VdkIQtuIWOrTGV3aDzw2JLL8hzGNe+rSl8GRL1JctfSrGE1fFwvB+F3qgx9Hbwxpl/rRKPLSgNUzebgAEM4gSvvHOn1fp8xquUGh/dMKqcvSqxph1gV87pC83+CxC49qzB0rF+YYoeyiTkmKonD5ZmRc1cM3Yvp2kxKU/aiNMuTImx+KwNPmji5UjDejpf8mWKI//JIl+lZJxb72oL2Qi96sRo8gQdQFwq/7llEoXP+4UlbNSvViX38XGkrr2PpBDPI/rrzSrd2lHL0vDsYxUlIDjPX+aww/Jp1wletgXGQBFiq2ANOLIFCdBkygFhTagjkB2eHXl8tcx7AjHwFyVibmmhbYi78t6FLyiR9X2uy6qFaM35DlO16euQm+W3mFk2U+PNGkFo242CzkPFhtqpfL/Kn+sGbsQ5PfX5EV4+Qtt6arjGZ/XOFiJQgP37YHYai3pNf2/gYCDq0cM3NguN7nr1aGpV0UN+Qdr1rw7DwprynjJHnomsgBLbG0vKuXhXCSLMmKcE6Wyd4rJSN6BUEEmQkiaDI3YFq2Kq/TBrXG44QKgyFt/Co9F4P7HXaGnBe3JnWkBHcK6RiJsrA/rVI5fyPLcTMWvLy+Jry12+EqROSBqZkOKOkMl3YgX5gouREKO8sGec597Wg2adQhEfryvLP2Ot4PvcszxAFxHBziGcPrJfAicGade2+o7T/f1a/02lZ2kXaPUq6CnRWs906z7r66Ay2vyyNA6kuHxwjfc1JXxUJOfcBI6Ngj91XeY3XnVXOxuWoWvIRIqQbdIfYt94lr1Kcr4t3VtXBAvCHQIuU/zvOkZnUjR0DpOCXl0/ZdlqyLZr1QFqWY5WIM70cj/cPruum9+5TFkihTm0lDxGV5Q9hGuKYEZNws1kSu2nZIU8X4uz19rPbWAzA1Nrzaj6TRmC3CDrW/Wg7AH/H8dJ3V2V0MamfQjvZdgxTDnLyMd22Ucr0xESsoHb5LBNcR12/oC9IIzu46y2ZZNjVrSBqQp193ksdmpYklHPs23tB2liLcP7MjPhn9QTI7eFjGzREsNfSecckAg8A1pJaT2qp5i1yMazkM/KOLz48bP5PZLXHlpP9aFzJZ0xSNRsVotGC0YRWxP8a3Baf+U5pEqhuUzWBJak4WckzxYNOQQaR2EEpJsRwnJjYU1V5JIWPFdV5NIzPbNjxjeJUb74YGafP1Rpuvg3yYZKu81Z0H5bgdytFE+SArm3TdPJn9gZw6m7FbX+Vch3MGF4FVXkSb4BSQ6QwT31JyNRqlKxvLmn0kEJ5RMosmXSEUUTb1OtPerlIdMML8geQ6EGhgVtQ9gcyO58o7n/ge+eA+6zrsvl+lw2Pwa5yog80xpnJtQ7yuDjiaobjje8qNg726AOSh46nvhGu+xjAqIqcpAhD9AiT8jOwQ3qQEzyzEQbmbg9cqd9EyTBshqfdlbkQMU5P1POZTlXquYhKxqSzS1ty1M4DeOAZX2WQMQRm321Q/w+OU5sPjLBmrj1NxdJQlyTDnoxFRfgQcZCmCMlPxDs/m3gH2PVioYI52Ot5KqeEZWmiBdqr4kqQzY1xjGOeWtoVycKfEc1uenBlQ6VNlamhRBX0UtyCzm64FgNOFqdP6FbhZt8AQaHqcnXSC5Mo1UrbXIkXeU3LTT9oRwxsHhr+F/Jhs/tAoP+rN07zBw7TIC4vb0rHSeEk/FlW5HKhyBmw1eDIeP3uSoEmTF6Hyded3R4GHJ7h5ukG7FO3AkR+ixxXhBdf0YpUW/hVaoXAuIJ6u6iuUnR2SatJOjSBxo6fFLl3E+CsmeIXrMOCrK6I+sBU2H8pAFM2GJ3Z/9NQbH+opycypTQmLBGnroNhJUWkPjMFWezLyTc4ikh3HSXlTEw4bc6It3HraGFdOHNhK7xDV3uYdT0SLyCSOjqyUPFMWSZKgPKfdaXe5JgNOftqQRpAlwJQNFoyKoqTNIDmiR4kFninEACbBIDkCD1QSyGvO6cIPew6OsGFnuHJqTKvTVXm0WTqyphncrhINblZEHilNaXSIMcyhyCTrU2OkNKKHwcSeJkXUPTYc7TDE8gcbw/myjp5uwUjCsTJ2JvJkf07a6fRQYoh1vG8h3tmgXby5GZ0H0gl3wCG4gTjgCIsdwCXELH6ck/m+k6SjttrnryWmKRmTT2SxEeRCL9Ols06Fhrq7KRsyViPvajJd92mEYudP1GlHlxvsj9zltsTe3sn93GEgQ2AD7htAYVFXSeCvC6zJMQEEOax9tJb8uqnG7nyoNltZnXMYVrW5h+fPXJdTtAir/mx1aewc7fws/yilpU4bmCeWOZEnJCnq5UdHHdWJx/DdIYPD7n25zDZYkZ0JDG3LKFbUZwSDurrJeAvUizmR6yorsJ59WbNDuAnnYLsO2xb+HUJid8x0+2f5PrPkcqnkbqAULE0VrbjMWxzhIjf14iYnenhAyoGWypNi3waqFfUpR3iRD/0D/XbrjqzFB/CPQG2CSZpwUrFimRjdVkQ5u90ukFZzxcgJrxpSjqZpQoprwhNDQEdLu92ycXf71cfRhoivOLttCIfi8HDIxq1CB1OEO6oROQl/XJj9w9PQVAg3eIMQDic0Gos1oXE7br6hugNIWmFFQpfeDmVY8zVVcokLhLKF7rtW1HlMZ4ZS0jT9x7f9RP5H8WKVVvoc66uBWxxPv+Uh8TnHpeL8Xe+v1zHJzQ+X3niXmWwY0cb29M4fFyY6o9c7BGEncujg5YsB2GIPymZAmRiQnzZFNRAMjLj1Ehq0tQ3K5SDpcrVIZw9PEMqibHKDK22IhOs8LadvN+l9UddVKUUjyeVMz2blThXx1zptbyvamKv+/QHuiFA2AVLxMPeiy8SHIBSi2WiUMg9FHttvJVgtmSsWhaD1YuWV17rvyANVzIelddHBodJVsvXeSyLc78/T7yfYnTR/lZOmO2O6pFCEsDtqoh01ulPecN3eth2aXDFWkYK2qhKYBiXK9BXdOHJDl5YtUq6vRWe4pUSuuYzgdgFK0rpnHoodbTnfdXvJ99qLuxGXq7TbEquQIBPjINdSB3ulaYVxaVuAOPF6lVLsqyVtc2OzP8LGGv/WC+I3ODhSqX+vu38AY0sl2l6x3frMYJjnzPH4HJ60KmanI3guwo4I6Ze98peDJiRFmCOEFy5eVdodMtHXU7ImUh9aExbB5Kdt33Gs7XqML7PYufMnxnoO7NKp6stMjP0aRqNFCFmVRponDmqeO0TySGM3Odm5Do5Wus/trH8tReiiv5YuYbALRLSb9/Gcfd1sGFHXJuB/Ch/asy6HJxMNZYk5SOjOwgRx3Jth1uRx6k76Uh9P0vamtkVUVii/omOHllLjwKidrtqBvE+rXL9FnchYOpvWwXpqVtd5Ox5gkfZ7aHEHq/RRrlrlKo20rgpahTXd9nypOqhC/wB3LLdGsCbuBvBupHDLjJO8sDaGZpSU1t4Iohq9K9R16xoAtVo337EiBKvQzts9oZkLMIgcWOgh6FgzDwZKA7gcrDi7GRSDZblaERBRofAEqXEJgPyBhuDdL6bgthRrr+ZWsW4jiqCJaXM4j3UPTRzM5An/fYfiydERR8RpyYzPMXWf0E5KCwg3O23wbYLmadurdGP6HSkrBv1+07r+mhdeeAD7tgX/t6+UV7DBQ8Ybx81nY+cVy/csw2BOYncSpjEbKpy6ARKQcr/GKc09QQlNqYazVMI4MqEA1VYd7MibXRbjY0qzEybdITRpxh5CV5PWvpyGOypSho3ULw87oYbFLy16+DORkNqDEhwDSdRj2GX/Qz/QfSAp8DzP68CURytfWvsXeJzUocmXt0nU7gm33nPlERaDSyQzO9ZXFLfGa8NcFRbqTYrttg40JC4FuMFcjflfV2kdm0YUi5jAXHcFZjs6UJArLS/y4bG6Zl/kw5NdqE1A94tpWrtmJse47tqYcFx3Tl3fLVL52pN4GArfhF2JEMKAKoMySStpCHxhz71UKYpU+Md4hUmiijwJrerKVZoWOUGjUTGm16364LmU++SoAw9FndYDUTDMp3RpXIHLR1BExjekaYprYghTIM2PKfmLnpIRAmlgk9ae2SkYCdrNWcqiyn2giJiutdOx4yWr/fT33zb5xmzjstFD97YQ67OfNkV1yVKOtlsdGc8m1CIjND/lEMHVk0PpTiMg2BzXrCddxLjK6dV4sIMg+E7EPFTETUD72UT0nsk1R43O7AjxkXS9tlh+P+4dq1Aj2e3LqEWZCaSN/3qYx0TEiJi4AD6qzx08Z8NCVRoPiTpmjRpB6oogSivlg9pqae7XNfUfHRRpNZmXDoKjgRRtYHEShK+1oa1bjcJTgdf9OfvwOJ2Ue1YgZoch+hp1jQsHMeEhQGeTEsxmYi7np0bxlY8KuJeFwL0PI/Z2xIOwvp6WGSgYFiD0QliIXJ71wLCojStpgkB4wKEG9WLSRZd1h0HW3MaC0IC0D6SnilkP2IG4tSEgy2NgV3tWj+e1ZZGKrTg51XTJr6d0eSEYV3VdbK6EMTHIeoh/Ax2n8GIDuvvKizsr7QFTtohZ+vneROHRQCaqqlQFCbFzm1FFW4tut0zRpLeLJJWdvsH3duKck1XGMeTMCF5oeShjHSijvj7aiwv4QOvtHbfC0i3t8mxBcdszfCYmsTVotAMPLcVSHkm4BcK1i8PJmMoE+zs67JXfhlfx8EwimVIHe1xS24E73dTdlQC2fOEptA8vtYgWcPgR5xAOdi2HHj/Ix97w56AR6PKz3h2ln5U9xMgCOspV+hAVfa5BnvOnY3Wo1UxF3pfPamicPA+sbO5oo8A7p+xO4HOiSCFLiERsTjzlWOlCzskqdyIUn5MV1sqgvNA4xRot3i4e80uXkAbZvWwI/2WVFgav2ULP+GZErU2aYzH5myAP2sTtULt+th4uIWgNpwZ8sM2hvS8NuKOe1rrPuOw9A/u4iXaanok/lGKdcrzZIyBp2LvHzGjIQFHotfgX8Fq8XqV2WCI86C8rpS4k64ccEb3DQhCMJYhZN5tjbUg4GkmpW5wKwcurjSApG1O41DyrCBjMJqK4AnPBBCfHbQy4g2IuS0JelfRDgu8b19OFtKFjdAw9FXBt2g06mM3IPJvNP0+w3a5TQ4Qy5Sjxebwkhoe4SRj/NlVWTh7n2MPo86pcfOia3MUMT+lanQe6n5B7LWKSta/QzrOjUkMbsxjdGGtHhIfHh3pCyRz7vaF0hb49qjeH8H3rTpO1ebDriQGvXa8Q62mi9l3jcBMZV9sn5hvCkVHt1GB9ckJ/nE555oM6nTw0AXbgorQ/qmUr40weYgzW0cl60nYZhpo4ricUMaqfiHklQfeeeex3C8lpNqBmvCz4NSgOTunyW05WqWzz//KVz+x99evYCr1+ozlD03UX7B3Gg535ml7Pu91+7uZCBx4P85xst2K7pdstNzetx5OYlxPUKoDi0Sh535BqlQxz522bXaPW/VPZJ0M4xCOJd3qnZ9fyZXRRy7kgRbazT4JwWlSt4Z8ip+txujF67/9l5L8hI28FQrp2wyrnMLuHQ6JwF9eR2Fzh4GsQ1haXWXF559lIwe0rI3HCfSZba8HXHkNA7JbbDevbbizTNegV5HbwfVHH1KFyuZSV1lKoI1w/oEzsoEfQxOhiWqFW1SvFWKXeCzlIW6VmR6QvpIanG0ET8OBxO7VTdkcdEXd9sER6bCDsMUzixbeHxS4rtmWQDtJ80HeHNdnQt92mQiGFrKPdrAyBwipjVcVarLHitSetEmfKQw846thpwVJIAJYiwpluprnk0y+IULEkmX/AWzoL4n3hGSI4X8yHsxZI5QtdXauxinykxQ3J+XZb1zi+BlKbDDJEgS32bad+l/TM+baSyEb9kpZeFO9ylQ79HvLmc1ChGwPPVjKBG3HgQIBNa3nK1GEx7nusU2sNsHcmJyakox1YNXlA+3fA5uTE1urboIZBgz+LbGgVFN1aI13csZFRQ2hsxW3CxPdjtO/HRuL+LLT76+C3bECw5H4D6l8UotgvmQQ0TGMvW0XYshBFdr97nFC9DMDsfm0X+per5m5i4qxTmzo+Xx7iesGmUoTYefYmqC2RxIsLDppyohIuUjJes0b8uSS3vXdRQXftYUp2rU2CVbFULDBFv4Tph5x9TG5KsFyJK+Alt+q6ikJJDg/qtYYzxQwKOigqTorlXTvkGt/fjHxIM9Fm36nIhcHc0MzSRh16HihM047JnB8mympkjbN1l/OHMlq7Azg4nrAfFmvAhQhngg4gE4xaACG00HVoetIAI83AbjIU2+7HNwX/8DXjECgwnAbusPawU2NVUDygcnFkbuJI11ZWEdjpw5zGtvnrzvWdSZTnea33Tn03mOc5W0+79WROLUrUUnemsgnN2of82/SL9THyauXJ1xM/y7gA0CpiT+045Gpaqs9YtxMtWRa9+GXqcjMZbSghVaWLQcdarMoWQ02WGfF6IFEMNeFZe+1NzWodVDiGvkjEu/qtJXCf03XTgebS53CtwINBex0LqDYItHg7hF2HbYd23VXp4Q7XnfH0uLkHw/kn4QsM2ue8vTN0dQvqrunzK6O8SuPhajDLZ3PP6L3MC/Aky0tr694oW/f2lQGPdPzINx7wKVimLwqANB2NNsGtmrWU92/VmMKNifRXpa/PcKUh/E3E4/5ap35pMHAasZDgDULZxjL70ai/ZoI3DjS4Y5RPe4zym9FI99dolPK8bI3yuTLKLz2jfAuMERjl/5gyzZr+4seKIwAWEJ2XHcyzPXi3XT5h14NjB+uYRnhwr62PmdgH+Cr8Ac4JpmH3moElZmB3OiS55In1QxcGFjJ6NEppfu9DNxoW+bEktzXj4mLBWeXCC8P6acFLi0a00KNgpwfe57mHr2KEFME4WbbJFZjz/S7G9srgpJosy0aK20vrB64pGTdA4VvWlPL5HGoBYUHbWYQtkRz121KmulOvnCxpclPQTVElXp8o0aELfKiEFVWISmOEjsZ5F8mngor4GWNYc26K/dGSI9w+jsYoXEb/42KaakztGdFjCYGiwi67Jvq36eZUHnmc4RaO9ful2t7UId4MubAP2t7Rf/aM57NjlInwWik1BOZiXC5xC+ThdFIqzJLgAdzk6UoQfq4R0hvUumF0zAQjg/NbdH1Vg9ax1v05TQSrVUSjB+f1NDJAKvEls+MzO8bHc5QlhKpVc1jRo9EhZbdko0yMC7pYMz4axatSX1VZJb3eR/spJE1NiSjz1vxno171TGfcI9Op1xiSd0W4qk4J9gFNfY44bVneLOCH80wDUD1CmunjTAYgoudzDP+yj1npovo+d2Qoufms1j6s/fn7529ef/3ym3fnp5cv37xOEF53Unz95vz8zZvL99+8Oz1/kSC8XOezusL3NWcfyyXJXtd405DnVdE02Zt61374YiU/6CNu9n6Nl6RustkVxa9rzNa4rvCfCb6g+I3AP63wao1n36zAn+UlmePZz/b3fCeT23Jrr9znptwvVnOn8gvaUvWS7vBijas13jjFrNYyxZ/B/u5eLY5LXixKep0NT3a7eXsj9HGdesEulzRNYK/nCf5CWwbd7dnW3YPUivFzxoTnzGkKvzfu7hnBmkreZLPlGt+upfhqSV+v3R64Mj0w+8J0Gfw5hZ6LtpdCfIj2W1W5Bd6YApsKQzilc5IutDOdHJrV2i239oi5bocDf18FSRtIevapbITsZjA36wpt09jLrFo7BS0pvtlUosyGx27lH9c7PPvkjPEnEU13Zoj85JF36bXkIp7orV+kbczlejefgzpqxXgQqFw8MMIwvJDZu4m8XgfI+VSv9jerVUMgtnhDhHpI/W9qsGpTQAuzfxOWGZE36XjTkG+LZj0FVlApg3CY+ep3W9yVCcJIuso0tUQ0gIOe9ykayAMDWQ7Ebbkg48Gr4ue7gRKoB0psbgbKTBSsK8IyVFB55OLb6ptaCNlOlklL261zkTuz43dHvPFT64E4A/zTKppg3hb8fh1zWsQLR3jfjEbpxuIMq4hSXyjgQC/n+zptEJh8V6NRGnUpzCuEF/Ax4iezQHjjOXJBQi+ggP9dpu/D5IO8vXEH+vMBDS4DVXLYKn9VpWhS7zdQWo0rdq3CxeoZM4DNLBskR0rcE3wDKgjQZmJIn3ooZuad/gGFndGla9G0iaFdQXtjIQqiqWUre9EfoKj+WAZ7cspiO76fZi4E8Q4iKWX2OASOmjLxiAh9eRB2Qg89X/uRhQLkaNj2PvVue1oQsro8q9srhdPTBpSck2ZTiTcrD3LiBaNEB8qIunXV9UuL8tIHnO+eAjxl1qbqgDepq8yOg6sOTQzmwz0QeK12ICcQdJv4lX2xUnGIvZerNSx8Mi6bV4Ce9ELL0ylD2237+oyat0gANJ8xy28FcMD96wQ9QPyBMAdtceBNbU4Iw3hpvSC7naQDfRaA8MeRoo6SJ5Jx92KNRIxsSDBzpkbVnKXhp3x4rFqmjrjxeYV2mHcJa6NZdJxErxgTjeBF3Y3U4JtyhGNsnAm994u1vcvx3tdrOVG67+UEKiPvryiakDzPy/aSqAEocXPZ5U8hgaaR4Uj1XX9nHgo0GrEH5hANVeDgLCTrSBFmPZFAUode+QyQ0g9wAu3b7IRa6U0py66IIGl4ZAv6I2Iio4HM3nun5U6PbbfD474vVgaIfI1TY/p7DznuSo/Tc9JboydTnvlM3eeh46uSLlPiyHcXfvLOIrA55AK4dM6Oaid3yk4Q/rDOv+DpPaGLom42lQo19CVuxF0FAWyxuc936D13Cfi+TI/xLCUpShG+YOkxPvmP//zP//zy5D+0d4f858QYJz/VF7VYO1rE/kEIr8v0BH958uXvfvelen+MyzWesTV+TfHPAs/+C17P8RvqlIPmgb8dSQU+wcdIRwOCDnm5zr9iaUKvnzoWKIs6hsnQbdqx3ya/kG6Tztf4w9o0599/d/J/bGsWtZccub93+B7+m80RfhtcSp4Gz6/37PVOjDV188z4DYz78nVxQ1rjOq11+flOSTHawGFqX4MFVCSigKtfGa9JIc9NrcWeAf3/G42h/jsgH+BD82aVJpkCzaF/OG7d8lTc6GNMJQvmY8FesVvCnxcNSZULpkpAj07QWPDyJkUTMb4p7q7IBRGvvQZDpAFsKR2viyZlaNq+kLybIXVDU6Ks/SCPcgzPyjna7dAu29vuAFy603APWxqcZb02TTr9zOF6Z8bnkoW3cYLTkDwu29bTcggXKkmHMQ1Ijolx6yKKnG2lRaMHc/uS+C1BHRvIro2mKmribNTuWIQFWrlRHrJt8HMxO1bKQL8+OQARkcVtgfJ9WHF2k8bWh7pybGItOa36Ed1j3RNrjTXx9KVnQvtMCOAapGKUpPfy1JURrPxUBWZ1lhRJBBXkF5XUdEpS2AK/qLBlp7D4FI3pjcPxkJNMIG2/E36Ui0B08BnCK7GQJRr2ZuMf6Wf32sEATbD67ms7V0xCg26iH218JMM2W2uplsG6lak3cb9qc7cJiLEqIeACRRl2OEsNuX1RN0lkFRA7YYF9oTj78hkPxcSb5hRJPhQbHZkyfK9zdC6U5HzyVHVqswBwzEl7VWx6ORjLh4bSfIKxw9TtynBkttvZHI0XjC4Kkc7EHGHaWbJmcCJdTUBBErB4Ha6JjFmtIzYVSQZ/myQzu2IbFj3cEJROcEbnKiReEPNIzeuefYBoS2rFcnmeJoW5epp2GJZABsNMdsKEw8ao4Ys53qiRdjOpJejHk1qqFjG3Rcz4zUeqlN+HpWmLbF9a5uV4VVaC8MjygJg6zMoQCmdWdYgGozblKyZmI+qGM9F+RlmkUaXryvzYEgN7SL2m+hbmY3aofcu0BbjrWXVYhAvX2kO8eZz5GaELtiTfkbvYpvhi3QlmotKDEvfAHEuypwb18d35y9YGMp6/t8a+ErxT2gvv2EUjOYxfW/rsX//9+Nl1iZP/TtyX/3YKLzPv5Zf/Di+/8F8+h5fYz/4VvJz4KdXLIz/lC3iZ+y+/hpdTP7t6+SxRh6O/7ztO2DP0aJQSq0fXmnM1eY1Br3LJa1xnKsnSYUNq36lOlGK+/rXdSg7/Zo0JTHqlTNZhtuQLJVz3mgg3NVmUq7vBFRPrQVvAoKAKplPL5sZK+KaocwB1bJMavZCmB/P2kOTI3sKcbUZ7jjbCPdrkiTy/NBACTExntJ3QgIKfzDP/nT33CITw/8/ctzDFjSsL/5VBJ8VnH3qGmQESjll/VAJskk0CbBiyyXrnpDy2BnvxSF5bDrBh/vstvWz5MbxO7qlb5YKxXm61Wq3ultRNTPIt89jGyLanMOZqEPWGU/Bd6o2mULjSChVLtl1Ifcbn2gPnZTEUwreMYmgmXhXD5Gjp1GbMIWh32whbWpXz2HSP8hYVH61fNyb2PnH4QrbUXFd823Bt8RSdhH9N6CNP00B4dXkJq9Q3VukYj9AEqla75P4nKCu8QcX+n6ZDiM2PH6NEdDX1dC2iq7W2GqG3mh60xVCNg0RZ3RusQblq3lcrmlUdr8XlILJ2A1om3UAu2mi2IyeuCM/xJ42J4Bu13w8XfoWljjftmHxqWflSNhhtne9KvQlIyZtrnPpeObdLk1K4lg5Tytmj1RuDj9igomfVQdIly4TaUFWpatC6WE5tbJQOaNSsRqzUm1SHO1tTkjm7QzJXIjMvsm9QhNxLrEvMRB32rXzYlEDK4kCasnI8t6ooeared1lPi5PqS7LiUtvJmoBwAITFTC9BurW9/mhNBA+RUTkDbFEYmaal/TaYme10wrBcNofKNW4aVJLTB/P2dkHk3bSwchAseNurYj7H2fp67Vi9kVPZvz/d09yrhM4a7fCkqoE39zTwM80Whz7zG43oZIH09/dco1DO4iqJKEv0eeAZDW9qN89TmrHTjF5kOM/L3dermEUHGQ4xYbGf5OaubEpJjkVkdvRnTok6LLzALKKhiCV2nqalkdRcnbTmqYj78Oj90eRIUfjro4n69ebo5aH6eXI6eXtyfKbefjk7OT5FTum4X4f+1Q4ilkvLgMS+vc2USCF6XIbNI/tEnt6jbmY71CVANSdo4kLGdzKSVuBmjTbT5DZXianqAwb26kVsoFoh0qW1pbTM4GXkqQFdRL65OrmhE+tI8KbJ9TiywahaU4ZlkhkhTEU2jitn8ZKYfotZJB0wuGyvdFTmu6wSOve1oNsoviEj0fr7aB85/k9asu2P9tE6chCyN+Kloe6qHnLQ/4ygq8HuOzjKZ8YrPvYdB/2NRYOTxz5PcD5EFcHYt7ef6q9v6q/drkxEY+Uvp/xlzuQ/o6qEgWynFZG5LHV72xEbpcqsy7UVkPt8ygwknPHczHG6AGh578SBvFAod2TfCCp6MDJr6JJJNYSaOLhJsRRM60Mga92BaMTwNdtMEz8maCWukXDXLveqN6/7V1dX/TnNFv0iS6QAE+4FkZ9xWfN88nN/F909EDLMwePGoQaCYJod8nyH5LU6Rr1kcsoaLV+EE9EiS1RiIcIPshqTqW6flkkQV6yRKfJt0C74ZpEGp9tvpThdTBJys406V91vJjgd3BgKl1V8zWRrMq6+YAYqQ77s1Y4ziu/mmL0peWzhmvqlmdmOyoqN45FY2ZPNGkKNFLH2ROqpZtJJ+xsqwMTDPyEryC8ktjzGiS0RsAakupI7CShkOAU0cJmDOdwOheZw+aXh7Tzq0iaxhwdnmDB3OHXRmdhr5knnaUL9sFwsR1MX1ZNksY/q44p7jKcuqifJYof0itTa25q6qJlYb9HdNtpSMOU4c3c4JLloeGl9X9rw850uepqXrORcGw+HRkQ7afRGJ+9QfYF1cUWScnHV96R8VhgUj1XKvv7hMLPgBF+zsgx/ub2tYiG7WE7qSmSjl65R+f9zWPXJf5Hy09ZwKFwD/V0fz1JMZHcyFywv8Al9TW94VQoeZ1XuedQYVyjvTFOxDyaDAHczNtw+aFza9ARxM+u7pma8YsorLN6F4AofUCHWqWO5MQZQZImD6zxUn97hk4QtrZ8jG179F9AKpCG21nmzPK7xY3EuGjYwKr6Hm2vB/+mR+evOkWkPAwwBnZNLQq+INOai1sAIH0HoDWOpKFDxG8Ln4doIiI7M4ZL6jCTGdNwXLfTmfpwUGe6FhbAMp36W8/9zmvXQhqVWb2QVCqQiS2xkO/W6mpvfU2sDOT20wRQMG8h4EQhVN3FdJv8r/tIiKYHXSpf+NTINZ5JkWJsmgM6EzzUHD9QvUAsVVotzc5XCzeW+tmjhusjSXMFwU9qQkUpe33cSOVLn2DvPEqug/d0uu40dh47bEjW9/X1kZy6ulKR4L3aJRpRZ8DjaL9MduZpYZYLkIloQ2yOVHui7+qUh9+pkR+pO1vfKMO7ovKVtq12G9/IGQ6UmK1He4DclV471aPrNYSR3DiNpCKPKftAcTtIaTrk9lLunhZXZ7fD0FXejekzVf7klK85U18fk9hbJOwhIbGIrKtX+rfM9ffH/oR4YXkUiQJa0cJTtCb0tvEHK4iF+O6pQVlf/lcGPaw4zYXHSlo5esSLSoTJqSg69vr5m4Zb2Yxiw7I7bOJqTaBdGxKxQXaTpyYZ5B2U3Ejr7EdC9SujsIWCJgqvB4TrgY8HROmUVJUxqag8ARtZcDY5U7+rGqW6wmvWXor6miqpLpaWrBd05ybAfRMKrVa8gkubDnqK+Hu9bD22U5LiBlqgdq2L1vkhbltFGQMEaLW3Cg3bsj5Xucu5t8/XRpKtBznue2KKwKHY0yUcqvWNHqGxAWh4Bl+qWJVmqrba7LAayzNeDl+/fv3p5wPUEvQTKWV9nhJJImptK2lPD03qpjaUdHU191nAPdvdtv3rDpy8nB294s79GXCVteeWgHYvkg9s+OZvc0XTxH7R83myYa0S/3XknV55yEcqYvprEcBbglHFBqXtXmM+4O/Zgy/rVb+0Wh39Iw/V7dU7+zWRy+vXt8eTo48HR6eTk4xmy4d3jTsSUn1pB3MbiKD//S+Ru/vsP+4/pH8v/B/t/kE141jjp/eVxEMyK2m3X2l3pzx/ec4H2oxwpBcHn+2S16yhT13C7xbWOkTCONcVzPYvFgTO1RdDipy8Zw4uU4bDHaK+8aNj7hTOKniItEfiUFir1IIkxYfI2qlzbkgQbl1BF66cdB7CZ0SOJLmluzwY0xcTSMAKum7ttaAm7IkBPa09C3HXSJ6zap0QMchAnM9RoSG2eZ6v9YUAqJI551hq9DDh1cWWpo7LOhZbVE3qVvRZ6/9z8J7JhrdG0Mjj3OZ9Etg56tNIcbdl7ammnKmRGA5hae0DtpTjOUxe95BZIPbVxajLr2vlac914P3akBCKDI7qNvQfLBnUOqWg4TFRg53WZk7mj8XjLdd1M683j4bajX4CU6VJNRifvkHLid8xFSnkmpG6byS3bhrjrJpHu0vnH9ygmMlKqkbZfe3M2//25r5DbF++LAeOsFq/86r7IqqdbqNYKsqUlXIR3FLRexsAXvfo7qoxBFErjmWE3IMI2EPPFNGkfti5ETLDScgyxq7Vg8N2aQpxL6zkkYrj2xsNtPrzChlsuNhUV7BsEwaGoXuW52FjEqk72x8OhM5TKW+DGyjIQ/7Q1lO7wBRkJllTfLmzteagAuKmb7CVuUh6h+yUChGT8zsRFnCATuekjnOlYicJuFcbTTcXN8cBdG0FS+vYCTsFOsrSXy2DfIlXM0FeRsgtVBuZyFGJzFHwxCnllk7GBmJfuHGVvEK3+FVnqy49vdglBB5Ovt4p1W3qy3N4OzVYbc6huAVraexpWvjynHFPz2rZMenurcVTwuZVybqvDE/Dxcs6jlkEbpEcDh0kXY+FyT+98HtBFWjAuw6+vW3TAKPMTl8n/Nkjm0kEidQIUVVM/49xfmJPr2Xw0BMDUXkLX4d8S7roNX0ONS6hxF9QKWrH7L6BWX2NVgIVs4IcydFp5UxTxNhEkNnRliiFAEMg7u6ZRQSx47QppuUswL0/8+DK6SSL88+lfd9aNbHlWkYSWX/ajxM4ZJmxp1zzHDTK8oN/wSuhXFCj73tm7zioP7+A91WUf/RnNmCUulUkZDIelEPr57OPPXw9OTt69Pfp6/PLDEbKBNXK5VnX0UeeSsC4vZuEDPLKGNNCSdpr4bE6zRRU9gF7GWNzNMRzXHYhUdfQOoSpjQi8xMU61CPZ3QAvC3OEKb66ySn1NRkJly0pnUBoqM+6Z6cY5pIGC9PYWodIgsGb4kjJBNk5tKOg2Npp9OEi0flChwF6BATND1FYDSe9AvkI948XPcPYtDkqfuJIVC5x3Kjur1AptWC+ypCE1cZRyfd4Qum9vpT5eSxKm8ozlwqU8ihhLnc1NLl62M3KRY7dVmT0j0rTZu3KsrUomlwcWMi5xmMJnAwv27a2FXaxPhras3PKUWr0OZPZS7AI3Vaz4/jGZ+cElJmHL5y0rXSfH5I7zyS39RwmZmphF/dV+CX6PwJuqIzvyU0ztUX+MLyLWrTtwjvBbpPwYm50ovSZU7bVQ4q9CialTqmvubV1yheOk0mkPDSt3X++ipXTExNWkk6aZ5U4jy4rPMGN67pffxGHlH8gssXS8aXnhpV6F1apUJXgV7f8J8gZ3LVYSk97ZYCzVdFRkiXsk/MRsoM0kJrhIB9L+1M0Y34siqw6E85blWU/VtrDZkIu3gpb4UB3iuTvH1ve58prVbQXA1mdsvY64QCdma4Xe8C1xUEYpQzqiWnJfd2WvSna2KkxHM5iGUfeZ226oQkbpLS8IO/wVDEt/BR5C006fBWn4mIv9eeoTBJ6HAk69CNDMDy9wT/ztp1m88LMb/RYnCf/mHd4M1IdOYqs/khkeenOIpnb92n8J6/zhsO4CSuIapEmcs/5FRou0HzO8eBhoZ9QaNXEwu89JQ9Wtse4VAuT0eMeMzC2d2UOAaplH1Or0FSH+paF0nLADo+dbu9vaccIkAe+YwEsy5Yzh7dzxhoD4DzRVXh460f3HtT+sffuMWi9ao77wk6SGTC769xcFw+GDh3jXwIUc4jrfxhaDHRgC0zF/Bs/iRZrEQcwGbw5N/+dl8fGK4q+LOMTH4jScDbzg1p0FhRzDi+2uKHb+8b29NOgwejgdbgEK428PpJgWtY0BFckKKn4Y4u8kpbkipS0Yv9jdGe9qWjrStAQ4E+T0M81ONEWJ3yVRdY1iHducBktHIyUKw4ejcEejsMICb9uPCc6ePouj0cOncTVdTr5xBoyvenTe4xw5d+6ft4oJRArZ24+ft8wdbY2GL8ZA3OMEMtc7IVMIBVzs1tUfGwIRB+xbY6JPZlbRTvgobcMQ6lsYKkjiORnE+W+Zn6Y4tDLb/p6552RQkKvMT61MmxPwIMTzAaEhzr3tqXCtE/O1NsTXG0OIjSp4QJNQiBG5R6f2Xv1dqG7nxIpLuSxbWgw4CeCYswR7wDKf5FzZsYheE21bk1R111KYOb+FwouNn6Z9WbRP1ZAhSMInObPpbKtNOmEIQah92oxG2893y/mUhOAV4WMc8hiebm6euLBfPGJh32pPsbA/T/B1j//pBzQpFkT+XoT9jF71/CS+IGIhzfsB5upXL+1v9VJRYLu3mPW3erOL/lUUM9yb0SzEWX9GGaOLXh75Ib3q509dgrcARTs1WIn/beZn/Vnmk7C3uOkPe4uMw+EXjPbmlLD+FeaaQl9e+O6lVCiMaApeLTYs2ixB8jzxDwVJHFzy1M7DNu7aULv0lAWVgJ65a6M118WxhWFs65iklr2+ntmQLZsuncZ1loAj8J7NIZ1X7pyuCRxxDlFBK/iEAXxzlT+j1lYNbUNA8eJC4M1PmFiEwRzumHAi788SGlyq4WU0FYUigT0EaGso3vMsQID8PMcs30zoBR3k3y5EzlUcskgVfDRz7U1wktw0pZGdplxH/DqlLm76Yz7qi7Ac+K0Hk9bz5nrr19pO+2OxM9QP/eyyg14kX+Bf87wRIBkYFsFwyocORRmeI9gWuT+KnF5U5EQGs4IxSoAMApYl7/CNOPLHfPkrj+I5e4dvVlHdC3j+YvRiuyQ7VpIdp7hHkFptEN8rjNSw/K//CMv/+G/idzT8YQgeDf9XMCxjeTQwPBq3lq17UCyRV1quLmIWFTMuI2wyPg3ZN/lflNV4R19niU8unzC3X4vmm0Bv/yifeDs/yCkexyLaRFIdeCFe1BSXSSO+cKJ/6LcdsWS3m3mupZcXtgoWXb5ytMva/9KFOMmZpfi7KKZOFy4qmUYYH2BSPFmQkQ20EXoRwk3Y6ZFvUjzMI9+sYQm6CledkBHbd751VoA3KaZdXakdlVZhkZj7fQnE9abApytQd7hHf9J7Pnt0Y6PcLffodC+WllbXdQO2vr4mrwqKm75yvg9tGA1fbL3YHu2Ot9fjwTzxL3Lh4l14uZO1bYjlrUGXAvN+z8r0qRsrabW0JQmklGa4Vzfv8I3DDLscBuUx3CEQ5x8pZU62XFreIbV2RmNOpq8YeN4ueG8j+BbCIuRsbQv+ZlP4lU1tOKTW9vPhLpAQshC8wwTeMsChkUND/ngkBKaSd0bjIfwedaDYw9MleNSs/iXijydTno+2t+FZpKbvl8go9znij/csMkq+1CU/myVPI4hD8F5G8Akbya8j/ninkQGkn0GSgedtgZ9NjbJXCXxNwPMz8MYwS6ZGlTMGE6bhFSk4gzyrpbAMijJFNPghgE8BR58B/WGmoP8QGCXfBvAyqLVGgpbGpJ2ql3jlxH0ZKIoXFxj+DKxM/joOLF2cY/8wgS+Mj+Jhwh/+Pca7eRqYGMgC/ngkgC+KDEZbO893h+AH/Cl7IgpHAX+8jGcZHfxKVAcjMzUOVKpvdjsn/PH0x0TH0zkciLXLKJeIIBUmueSaCJKoBmgQ8YevfDJ+xicMuUkmhYh1YSI6jeBC1pBhGaqcSQRnEXjXZtopW0ngEw2JmOvjra3n4If88VrpecifdvpJwp8yfbwNCYNfg1pKSNohu7xvkSWGuYQUriP+eHoyiKrXDLr2LzyLuBg+J2JzdIYRsMAWrwHNsNg0yhHE1vcl4AAsIt1UtC/uGZ4gPCZujEzFBv4lJoA567ZtuyPaGAuWNhyJQA/yjtASPG8MIZmCgXk4YvzhOddsqod8tLO7DTPCH+8L4yT9CXOU/c0Lt7AbZPzxZqSV8zrgD+cIr/V8EAiLIphFIv3ZvGIHcJzCSWoim0b8UQnjnecwj+C7ihXhrA2X9SFNYBGBiCEyhiCZmkQHacIfL0mqpBPGH+NrZwTeEvBOxAS+JCbAf807iMP7nvoschCCTEWSmlCnFDaAZ37wWRA5aF4kCVqCKq8LlLYcJwmX02m9N8/m8DWCO4PXjOH1fMr//T2ftlB/E/GHj2sUiULPOgrNQv6058tZwR8D7zgEsS/fn5y8OzpGZhbjWf0VmQGDtSFPmHJByLL3jopBmtGwEKhcX69vkKcdPt+V+yvpHrvH6/YWNMQ94cS9p7fQezlmRTpA9l5A3LXR0rLhr8CyK//RcpdNh7+9Cu2BPLXUIbgElOQ0weqUDuaALwWtDqfTqb33PwEAAP//PtgDIw1SBAA=\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") +} diff --git a/api/guide.go b/api/guide.go new file mode 100644 index 0000000..5fb8277 --- /dev/null +++ b/api/guide.go @@ -0,0 +1,62 @@ +package api + +import ( + "encoding/json" + "net/http" + "strconv" + + "github.com/gin-gonic/gin" + "github.com/tellytv/telly/context" + "github.com/tellytv/telly/models" +) + +func addGuide(cc *context.CContext, c *gin.Context) { + var payload models.GuideSource + if c.BindJSON(&payload) == nil { + newProvider, providerErr := cc.API.GuideSource.InsertGuideSource(payload) + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + providerCfg := newProvider.ProviderConfiguration() + + log.Infof("providerCfg %+v", providerCfg) + + provider, providerErr := providerCfg.GetProvider() + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + log.Infoln("Detected passed config is for provider", provider.Name()) + + xmlTV, xmlErr := models.GetXMLTV(provider.EPGURL(), false) + if xmlErr != nil { + log.WithError(xmlErr).Errorln("unable to get XMLTV file") + c.AbortWithError(http.StatusBadRequest, xmlErr) + return + } + + for _, channel := range xmlTV.Channels { + displayNames, _ := json.Marshal(channel.DisplayNames) + urls, _ := json.Marshal(channel.URLs) + icons, _ := json.Marshal(channel.Icons) + newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(models.GuideSourceChannel{ + GuideID: newProvider.ID, + XMLTVID: channel.ID, + DisplayNames: displayNames, + URLs: urls, + Icons: icons, + ChannelNumber: strconv.Itoa(channel.LCN), + }) + if newChannelErr != nil { + log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") + c.AbortWithError(http.StatusInternalServerError, newChannelErr) + return + } + newProvider.Channels = append(newProvider.Channels, *newChannel) + } + c.JSON(http.StatusOK, newProvider) + } +} diff --git a/api/guide_source.go b/api/guide_source.go new file mode 100644 index 0000000..2f2b041 --- /dev/null +++ b/api/guide_source.go @@ -0,0 +1,17 @@ +package api + +import ( + "net/http" + + "github.com/gin-gonic/gin" + "github.com/tellytv/telly/context" +) + +func getGuideSources(cc *context.CContext, c *gin.Context) { + sources, sourcesErr := cc.API.GuideSource.GetAllGuideSources(true) + if sourcesErr != nil { + c.AbortWithError(http.StatusInternalServerError, sourcesErr) + return + } + c.JSON(http.StatusOK, sources) +} diff --git a/api/main.go b/api/main.go new file mode 100644 index 0000000..4febd82 --- /dev/null +++ b/api/main.go @@ -0,0 +1,84 @@ +package api + +import ( + "bytes" + "os" + + "github.com/gin-contrib/cors" + "github.com/gin-gonic/gin" + "github.com/gobuffalo/packr" + "github.com/sirupsen/logrus" + "github.com/spf13/viper" + "github.com/tellytv/telly/context" + "github.com/zsais/go-gin-prometheus" +) + +var log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, +} + +func ServeAPI(cc *context.CContext) { + log.Debugln("creating webserver routes") + + if viper.GetString("log.level") != logrus.DebugLevel.String() { + gin.SetMode(gin.ReleaseMode) + } + + router := gin.New() + router.Use(cors.Default()) + router.Use(gin.Recovery()) + + if viper.GetBool("log.logrequests") { + router.Use(ginrus()) + } + + p := ginprometheus.NewPrometheus("http") + p.Use(router) + + box := packr.NewBox("../frontend/dist/telly-fe") + + router.Use(ServeBox("/", box)) + + apiGroup := router.Group("/api") + + apiGroup.GET("/lineup/scan", scanM3U) + apiGroup.GET("/guide/scan", scanXMLTV) + + apiGroup.GET("/guide_sources", wrapContext(cc, getGuideSources)) + apiGroup.POST("/guide_sources", wrapContext(cc, addGuide)) + + apiGroup.GET("/video_sources", wrapContext(cc, getVideoSources)) + apiGroup.POST("/video_sources", wrapContext(cc, addVideoSource)) + + log.Infof("telly is live and on the air!") + log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) + log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) + + if err := router.Run(viper.GetString("web.listen-address")); err != nil { + log.WithError(err).Panicln("Error starting up web server") + } +} + +func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error) { + if atEOF && len(data) == 0 { + return 0, nil, nil + } + if i := bytes.IndexByte(data, '\n'); i >= 0 { + // We have a full newline-terminated line. + return i + 1, data[0:i], nil + } + if i := bytes.IndexByte(data, '\r'); i >= 0 { + // We have a cr terminated line + return i + 1, data[0:i], nil + } + if atEOF { + return len(data), data, nil + } + + return 0, nil, nil +} diff --git a/routes.go b/api/tuner.go similarity index 63% rename from routes.go rename to api/tuner.go index 90e3f13..b6c1c10 100644 --- a/routes.go +++ b/api/tuner.go @@ -1,8 +1,7 @@ -package main +package api import ( "bufio" - "bytes" "encoding/xml" "fmt" "io" @@ -15,26 +14,20 @@ import ( "github.com/gin-contrib/cors" "github.com/gin-gonic/gin" - "github.com/gobuffalo/packr" ssdp "github.com/koron/go-ssdp" - "github.com/sirupsen/logrus" "github.com/spf13/viper" - ginprometheus "github.com/tellytv/telly/internal/go-gin-prometheus" + "github.com/tellytv/telly/context" "github.com/tellytv/telly/internal/xmltv" + "github.com/tellytv/telly/models" + "github.com/zsais/go-gin-prometheus" ) -func serve(lineup *lineup) { - discoveryData := getDiscoveryData() +func ServeLineup(cc *context.CContext) { + discoveryData := GetDiscoveryData() log.Debugln("creating device xml") upnp := discoveryData.UPNP() - log.Debugln("creating webserver routes") - - if viper.GetString("log.level") != logrus.DebugLevel.String() { - gin.SetMode(gin.ReleaseMode) - } - router := gin.New() router.Use(cors.Default()) router.Use(gin.Recovery()) @@ -47,46 +40,16 @@ func serve(lineup *lineup) { p.Use(router) router.GET("/", deviceXML(upnp)) - router.GET("/discover.json", discovery(discoveryData)) - router.GET("/lineup_status.json", func(c *gin.Context) { - payload := LineupStatus{ - ScanInProgress: convertibleBoolean(false), - ScanPossible: convertibleBoolean(true), - Source: "Cable", - SourceList: []string{"Cable"}, - } - if lineup.Scanning { - payload = LineupStatus{ - ScanInProgress: convertibleBoolean(true), - // Gotta fake out Plex. - Progress: 50, - Found: 50, - } - } - - c.JSON(http.StatusOK, payload) - }) - router.POST("/lineup.post", func(c *gin.Context) { - scanAction := c.Query("scan") - if scanAction == "start" { - if refreshErr := lineup.Scan(); refreshErr != nil { - c.AbortWithError(http.StatusInternalServerError, refreshErr) - } - c.AbortWithStatus(http.StatusOK) - return - } else if scanAction == "abort" { - c.AbortWithStatus(http.StatusOK) - return - } - c.String(http.StatusBadRequest, "%s is not a valid scan command", scanAction) - }) router.GET("/device.xml", deviceXML(upnp)) - router.GET("/lineup.json", serveLineup(lineup)) - router.GET("/lineup.xml", serveLineup(lineup)) - router.GET("/auto/:channelID", stream(lineup)) - router.GET("/epg.xml", xmlTV(lineup)) + router.GET("/discover.json", discovery(discoveryData)) + router.GET("/lineup_status.json", lineupStatus(false)) // FIXME: replace bool with cc.Lineup.Scanning + router.POST("/lineup.post", scanChannels(cc)) + router.GET("/lineup.json", serveHDHRLineup(cc.Lineup)) + router.GET("/lineup.xml", serveHDHRLineup(cc.Lineup)) + router.GET("/auto/:channelID", stream(cc.Lineup)) + router.GET("/epg.xml", xmlTV(cc.Lineup)) router.GET("/debug.json", func(c *gin.Context) { - c.JSON(http.StatusOK, lineup) + c.JSON(http.StatusOK, cc.Lineup) }) if viper.GetBool("discovery.ssdp") { @@ -95,17 +58,39 @@ func serve(lineup *lineup) { } } - box := packr.NewBox("./frontend/dist/telly-fe") + if err := router.Run(viper.GetString("web.listen-address")); err != nil { + log.WithError(err).Panicln("Error starting up web server") + } +} - router.StaticFS("/manage", box) +func setupSSDP(baseAddress, deviceName, deviceUUID string) (*ssdp.Advertiser, error) { + log.Debugf("Advertising telly as %s (%s)", deviceName, deviceUUID) - log.Infof("telly is live and on the air!") - log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) - log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) + adv, err := ssdp.Advertise( + "upnp:rootdevice", + fmt.Sprintf("uuid:%s::upnp:rootdevice", deviceUUID), + fmt.Sprintf("http://%s/device.xml", baseAddress), + deviceName, + 1800) - if err := router.Run(viper.GetString("web.listen-address")); err != nil { - log.WithError(err).Panicln("Error starting up web server") + if err != nil { + return nil, err } + + go func(advertiser *ssdp.Advertiser) { + aliveTick := time.Tick(15 * time.Second) + + for { + select { + case <-aliveTick: + if err := advertiser.Alive(); err != nil { + log.WithError(err).Panicln("error when sending ssdp heartbeat") + } + } + } + }(adv) + + return adv, nil } func deviceXML(deviceXML UPNP) gin.HandlerFunc { @@ -122,13 +107,13 @@ func discovery(data DiscoveryData) gin.HandlerFunc { type hdhrLineupContainer struct { XMLName xml.Name `xml:"Lineup" json:"-"` - Programs []hdHomeRunLineupItem + Programs []models.HDHomeRunLineupItem } -func serveLineup(lineup *lineup) gin.HandlerFunc { +func serveHDHRLineup(lineup *models.Lineup) gin.HandlerFunc { return func(c *gin.Context) { - channels := make([]hdHomeRunLineupItem, 0) - for _, channel := range lineup.channels { + channels := make([]models.HDHomeRunLineupItem, 0) + for _, channel := range lineup.Channels { channels = append(channels, channel) } sort.Slice(channels, func(i, j int) bool { @@ -146,22 +131,25 @@ func serveLineup(lineup *lineup) gin.HandlerFunc { } } -func xmlTV(lineup *lineup) gin.HandlerFunc { - epg := &xmltv.TV{ - GeneratorInfoName: namespaceWithVersion, - GeneratorInfoURL: "https://github.com/tellytv/telly", - } +func xmlTV(lineup *models.Lineup) gin.HandlerFunc { + return func(c *gin.Context) { + // FIXME: Move this outside of the function stuff. + epg := &xmltv.TV{ + GeneratorInfoName: "telly", + GeneratorInfoURL: "https://github.com/tellytv/telly", + } - for _, channel := range lineup.channels { - if channel.providerChannel.EPGChannel != nil { - epg.Channels = append(epg.Channels, *channel.providerChannel.EPGChannel) - epg.Programmes = append(epg.Programmes, channel.providerChannel.EPGProgrammes...) + for _, channel := range lineup.Channels { + if channel.ProviderChannel.EPGChannel != nil { + epg.Channels = append(epg.Channels, *channel.ProviderChannel.EPGChannel) + epg.Programmes = append(epg.Programmes, channel.ProviderChannel.EPGProgrammes...) + } } - } - sort.Slice(epg.Channels, func(i, j int) bool { return epg.Channels[i].LCN < epg.Channels[j].LCN }) + sort.Slice(epg.Channels, func(i, j int) bool { + return epg.Channels[i].LCN < epg.Channels[j].LCN + }) - return func(c *gin.Context) { buf, marshallErr := xml.MarshalIndent(epg, "", "\t") if marshallErr != nil { c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling EPG to XML")) @@ -170,7 +158,7 @@ func xmlTV(lineup *lineup) gin.HandlerFunc { } } -func stream(lineup *lineup) gin.HandlerFunc { +func stream(lineup *models.Lineup) gin.HandlerFunc { return func(c *gin.Context) { channelIDStr := c.Param("channelID")[1:] channelID, channelIDErr := strconv.Atoi(channelIDStr) @@ -179,17 +167,17 @@ func stream(lineup *lineup) gin.HandlerFunc { return } - if channel, ok := lineup.channels[channelID]; ok { + if channel, ok := lineup.Channels[channelID]; ok { log.Infof("Serving channel number %d", channelID) if !viper.IsSet("iptv.ffmpeg") { - c.Redirect(http.StatusMovedPermanently, channel.providerChannel.Track.URI) + c.Redirect(http.StatusMovedPermanently, channel.ProviderChannel.Track.URI) return } log.Infoln("Transcoding stream with ffmpeg") - run := exec.Command("ffmpeg", "-re", "-i", channel.providerChannel.Track.URI, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") + run := exec.Command("ffmpeg", "-re", "-i", channel.ProviderChannel.Track.URI, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") ffmpegout, err := run.StdoutPipe() if err != nil { log.WithError(err).Errorln("StdoutPipe Error") @@ -240,83 +228,40 @@ func stream(lineup *lineup) gin.HandlerFunc { } } -func ginrus() gin.HandlerFunc { +func scanChannels(cc *context.CContext) gin.HandlerFunc { return func(c *gin.Context) { - start := time.Now() - // some evil middlewares modify this values - path := c.Request.URL.Path - c.Next() - - end := time.Now() - latency := end.Sub(start) - end = end.UTC() - - logFields := logrus.Fields{ - "status": c.Writer.Status(), - "method": c.Request.Method, - "path": path, - "ipAddress": c.ClientIP(), - "latency": latency, - "userAgent": c.Request.UserAgent(), - "time": end.Format(time.RFC3339), - } - - entry := log.WithFields(logFields) - - if len(c.Errors) > 0 { - // Append error field if this is an erroneous request. - entry.Error(c.Errors.String()) - } else { - entry.Info() + scanAction := c.Query("scan") + if scanAction == "start" { + if refreshErr := cc.Lineup.Scan(); refreshErr != nil { + c.AbortWithError(http.StatusInternalServerError, refreshErr) + } + c.AbortWithStatus(http.StatusOK) + return + } else if scanAction == "abort" { + c.AbortWithStatus(http.StatusOK) + return } + c.String(http.StatusBadRequest, "%s is not a valid scan command", scanAction) } } -func setupSSDP(baseAddress, deviceName, deviceUUID string) (*ssdp.Advertiser, error) { - log.Debugf("Advertising telly as %s (%s)", deviceName, deviceUUID) - - adv, err := ssdp.Advertise( - "upnp:rootdevice", - fmt.Sprintf("uuid:%s::upnp:rootdevice", deviceUUID), - fmt.Sprintf("http://%s/device.xml", baseAddress), - deviceName, - 1800) - - if err != nil { - return nil, err - } - - go func(advertiser *ssdp.Advertiser) { - aliveTick := time.Tick(15 * time.Second) - - for { - select { - case <-aliveTick: - if err := advertiser.Alive(); err != nil { - log.WithError(err).Panicln("error when sending ssdp heartbeat") - } +func lineupStatus(scanning bool) gin.HandlerFunc { + return func(c *gin.Context) { + payload := LineupStatus{ + ScanInProgress: models.ConvertibleBoolean(false), + ScanPossible: models.ConvertibleBoolean(true), + Source: "Cable", + SourceList: []string{"Cable"}, + } + if scanning { + payload = LineupStatus{ + ScanInProgress: models.ConvertibleBoolean(true), + // Gotta fake out Plex. + Progress: 50, + Found: 50, } } - }(adv) - return adv, nil -} - -func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error) { - if atEOF && len(data) == 0 { - return 0, nil, nil - } - if i := bytes.IndexByte(data, '\n'); i >= 0 { - // We have a full newline-terminated line. - return i + 1, data[0:i], nil - } - if i := bytes.IndexByte(data, '\r'); i >= 0 { - // We have a cr terminated line - return i + 1, data[0:i], nil - } - if atEOF { - return len(data), data, nil + c.JSON(http.StatusOK, payload) } - - return 0, nil, nil } diff --git a/api/utils.go b/api/utils.go new file mode 100644 index 0000000..9651de4 --- /dev/null +++ b/api/utils.go @@ -0,0 +1,179 @@ +package api + +import ( + "encoding/xml" + "fmt" + "net/http" + "strconv" + "time" + + "github.com/gin-gonic/gin" + "github.com/gobuffalo/packr" + "github.com/sirupsen/logrus" + "github.com/spf13/viper" + "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/models" +) + +func scanM3U(c *gin.Context) { + reader, m3uErr := models.GetM3U(c.Query("m3u_url"), false) + if m3uErr != nil { + log.WithError(m3uErr).Errorln("unable to get m3u file") + c.AbortWithError(http.StatusBadRequest, m3uErr) + return + } + + rawPlaylist, err := m3uplus.Decode(reader) + if err != nil { + log.WithError(err).Errorln("unable to parse m3u file") + c.AbortWithError(http.StatusInternalServerError, err) + } + + c.JSON(http.StatusOK, rawPlaylist) +} + +func scanXMLTV(c *gin.Context) { + epg, epgErr := models.GetXMLTV(c.Query("epg_url"), false) + if epgErr != nil { + c.AbortWithError(http.StatusInternalServerError, epgErr) + return + } + + epg.Programmes = nil + + c.JSON(http.StatusOK, epg) +} + +// DiscoveryData contains data about telly to expose in the HDHomeRun format for Plex detection. +type DiscoveryData struct { + FriendlyName string + Manufacturer string + ModelNumber string + FirmwareName string + TunerCount int + FirmwareVersion string + DeviceID string + DeviceAuth string + BaseURL string + LineupURL string +} + +// UPNP returns the UPNP representation of the DiscoveryData. +func (d *DiscoveryData) UPNP() UPNP { + return UPNP{ + SpecVersion: upnpVersion{ + Major: 1, Minor: 0, + }, + URLBase: d.BaseURL, + Device: upnpDevice{ + DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", + FriendlyName: d.FriendlyName, + Manufacturer: d.Manufacturer, + ModelName: d.ModelNumber, + ModelNumber: d.ModelNumber, + UDN: fmt.Sprintf("uuid:%s", d.DeviceID), + }, + } +} + +// LineupStatus exposes the status of the channel lineup. +type LineupStatus struct { + ScanInProgress models.ConvertibleBoolean + ScanPossible models.ConvertibleBoolean `json:",omitempty"` + Source string `json:",omitempty"` + SourceList []string `json:",omitempty"` + Progress int `json:",omitempty"` // Percent complete + Found int `json:",omitempty"` // Number of found channels +} + +type upnpVersion struct { + Major int32 `xml:"major"` + Minor int32 `xml:"minor"` +} + +type upnpDevice struct { + DeviceType string `xml:"deviceType"` + FriendlyName string `xml:"friendlyName"` + Manufacturer string `xml:"manufacturer"` + ModelName string `xml:"modelName"` + ModelNumber string `xml:"modelNumber"` + SerialNumber string `xml:"serialNumber"` + UDN string `xml:"UDN"` +} + +// UPNP describes the UPNP/SSDP XML. +type UPNP struct { + XMLName xml.Name `xml:"urn:schemas-upnp-org:device-1-0 root"` + SpecVersion upnpVersion `xml:"specVersion"` + URLBase string `xml:"URLBase"` + Device upnpDevice `xml:"device"` +} + +func GetDiscoveryData() DiscoveryData { + return DiscoveryData{ + FriendlyName: viper.GetString("discovery.device-friendly-name"), + Manufacturer: viper.GetString("discovery.device-manufacturer"), + ModelNumber: viper.GetString("discovery.device-model-number"), + FirmwareName: viper.GetString("discovery.device-firmware-name"), + TunerCount: viper.GetInt("iptv.streams"), + FirmwareVersion: viper.GetString("discovery.device-firmware-version"), + DeviceID: strconv.Itoa(viper.GetInt("discovery.device-id")), + DeviceAuth: viper.GetString("discovery.device-auth"), + BaseURL: fmt.Sprintf("http://%s", viper.GetString("web.base-address")), + LineupURL: fmt.Sprintf("http://%s/lineup.json", viper.GetString("web.base-address")), + } +} + +func ginrus() gin.HandlerFunc { + return func(c *gin.Context) { + start := time.Now() + // some evil middlewares modify this values + path := c.Request.URL.Path + c.Next() + + end := time.Now() + latency := end.Sub(start) + end = end.UTC() + + logFields := logrus.Fields{ + "status": c.Writer.Status(), + "method": c.Request.Method, + "path": path, + "ipAddress": c.ClientIP(), + "latency": latency, + "userAgent": c.Request.UserAgent(), + "time": end.Format(time.RFC3339), + } + + entry := log.WithFields(logFields) + + if len(c.Errors) > 0 { + // Append error field if this is an erroneous request. + entry.Error(c.Errors.String()) + } else { + entry.Info() + } + } +} + +func wrapContext(cc *context.CContext, originalFunc func(*context.CContext, *gin.Context)) gin.HandlerFunc { + return func(c *gin.Context) { + ctx := cc.Copy() + originalFunc(ctx, c) + } +} + +// ServeBox returns a middleware handler that serves static files from a Packr box. +func ServeBox(urlPrefix string, box packr.Box) gin.HandlerFunc { + fileserver := http.FileServer(box) + if urlPrefix != "" { + fileserver = http.StripPrefix(urlPrefix, fileserver) + } + return func(c *gin.Context) { + if box.Has(c.Request.URL.Path) { + fileserver.ServeHTTP(c.Writer, c.Request) + c.Abort() + } + } +} diff --git a/api/video_source.go b/api/video_source.go new file mode 100644 index 0000000..ec72d36 --- /dev/null +++ b/api/video_source.go @@ -0,0 +1,75 @@ +package api + +import ( + "encoding/json" + "net/http" + + "github.com/gin-gonic/gin" + "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/models" +) + +func getVideoSources(cc *context.CContext, c *gin.Context) { + sources, sourcesErr := cc.API.VideoSource.GetAllVideoSources(true) + if sourcesErr != nil { + c.AbortWithError(http.StatusInternalServerError, sourcesErr) + return + } + c.JSON(http.StatusOK, sources) +} + +func addVideoSource(cc *context.CContext, c *gin.Context) { + var payload models.VideoSource + if c.BindJSON(&payload) == nil { + newProvider, providerErr := cc.API.VideoSource.InsertVideoSource(payload) + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + providerCfg := newProvider.ProviderConfiguration() + + log.Infof("providerCfg %+v", providerCfg) + + provider, providerErr := providerCfg.GetProvider() + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + log.Infoln("Detected passed config is for provider", provider.Name()) + + reader, m3uErr := models.GetM3U(provider.PlaylistURL(), false) + if m3uErr != nil { + log.WithError(m3uErr).Errorln("unable to get m3u file") + c.AbortWithError(http.StatusBadRequest, m3uErr) + return + } + + rawPlaylist, err := m3uplus.Decode(reader) + if err != nil { + log.WithError(err).Errorln("unable to parse m3u file") + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + for _, track := range rawPlaylist.Tracks { + marshalledTags, _ := json.Marshal(track.Tags) + newTrack, newTrackErr := cc.API.VideoSourceTrack.InsertVideoSourceTrack(models.VideoSourceTrack{ + VideoSourceID: newProvider.ID, + Name: track.Name, + Tags: marshalledTags, + RawLine: track.Raw, + StreamURL: track.URI, + }) + if newTrackErr != nil { + log.WithError(newTrackErr).Errorln("Error creating new video source track!") + c.AbortWithError(http.StatusInternalServerError, newTrackErr) + return + } + newProvider.Tracks = append(newProvider.Tracks, *newTrack) + } + c.JSON(http.StatusOK, newProvider) + } +} diff --git a/context/context.go b/context/context.go new file mode 100644 index 0000000..3af178f --- /dev/null +++ b/context/context.go @@ -0,0 +1,75 @@ +// Package context provides Telly specific context functions like SQLite access, along with initialized API clients and other packages such as models. +package context + +import ( + ctx "context" + "os" + + "github.com/jmoiron/sqlx" + _ "github.com/mattn/go-sqlite3" + "github.com/sirupsen/logrus" + "github.com/tellytv/telly/models" +) + +// CContext is a context struct that gets passed around the application. +type CContext struct { + API *models.APICollection + Ctx ctx.Context + Lineup *models.Lineup + Log *logrus.Logger + + RawSQL *sqlx.DB +} + +// Copy returns a cloned version of the input CContext minus the User and Device fields. +func (cc *CContext) Copy() *CContext { + return &CContext{ + API: cc.API, + Ctx: cc.Ctx, + Lineup: cc.Lineup, + Log: cc.Log, + RawSQL: cc.RawSQL, + } +} + +// NewCContext returns an initialized CContext struct +func NewCContext() (*CContext, error) { + + theCtx := ctx.Background() + + log := &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } + + sql, dbErr := sqlx.Open("sqlite3", "./telly.db") + if dbErr != nil { + log.WithError(dbErr).Panicln("Unable to open database") + } + + sql.Exec(`PRAGMA foreign_keys = ON;`) + + api := models.NewAPICollection(theCtx, sql) + + // lineup := models.NewLineup() + + // if scanErr := lineup.Scan(); scanErr != nil { + // log.WithError(scanErr).Panicln("Error scanning lineup!") + // } + + context := &CContext{ + API: api, + Ctx: theCtx, + Log: log, + // Lineup: lineup, + RawSQL: sql, + } + + log.Debugln("Context: Context build complete") + + return context, nil +} diff --git a/frontend b/frontend index 05a69f4..1f42871 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 05a69f4c0f800f807f3b8c28557f401844655fb9 +Subproject commit 1f42871b14badb0d714bafccf01a10a581d0fed7 diff --git a/internal/go-gin-prometheus/middleware.go b/internal/go-gin-prometheus/middleware.go deleted file mode 100644 index f3d7477..0000000 --- a/internal/go-gin-prometheus/middleware.go +++ /dev/null @@ -1,402 +0,0 @@ -// Package ginprometheus provides a Logrus logger for Gin requests. Slightly modified to remove spammy logs. -// For more info see https://github.com/zsais/go-gin-prometheus/pull/22. -package ginprometheus - -import ( - "bytes" - "io/ioutil" - "net/http" - "os" - "strconv" - "time" - - "github.com/gin-gonic/gin" - "github.com/prometheus/client_golang/prometheus" - "github.com/prometheus/client_golang/prometheus/promhttp" - log "github.com/sirupsen/logrus" -) - -var defaultMetricPath = "/metrics" - -// Standard default metrics -// counter, counter_vec, gauge, gauge_vec, -// histogram, histogram_vec, summary, summary_vec -var reqCnt = &Metric{ - ID: "reqCnt", - Name: "requests_total", - Description: "How many HTTP requests processed, partitioned by status code and HTTP method.", - Type: "counter_vec", - Args: []string{"code", "method", "handler", "host", "url"}} - -var reqDur = &Metric{ - ID: "reqDur", - Name: "request_duration_seconds", - Description: "The HTTP request latencies in seconds.", - Type: "summary"} - -var resSz = &Metric{ - ID: "resSz", - Name: "response_size_bytes", - Description: "The HTTP response sizes in bytes.", - Type: "summary"} - -var reqSz = &Metric{ - ID: "reqSz", - Name: "request_size_bytes", - Description: "The HTTP request sizes in bytes.", - Type: "summary"} - -var standardMetrics = []*Metric{ - reqCnt, - reqDur, - resSz, - reqSz, -} - -/* -RequestCounterURLLabelMappingFn is a function which can be supplied to the middleware to control -the cardinality of the request counter's "url" label, which might be required in some contexts. -For instance, if for a "/customer/:name" route you don't want to generate a time series for every -possible customer name, you could use this function: -func(c *gin.Context) string { - url := c.Request.URL.String() - for _, p := range c.Params { - if p.Key == "name" { - url = strings.Replace(url, p.Value, ":name", 1) - break - } - } - return url -} -which would map "/customer/alice" and "/customer/bob" to their template "/customer/:name". -*/ -type RequestCounterURLLabelMappingFn func(c *gin.Context) string - -// Metric is a definition for the name, description, type, ID, and -// prometheus.Collector type (i.e. CounterVec, Summary, etc) of each metric -type Metric struct { - MetricCollector prometheus.Collector - ID string - Name string - Description string - Type string - Args []string -} - -// Prometheus contains the metrics gathered by the instance and its path -type Prometheus struct { - reqCnt *prometheus.CounterVec - reqDur, reqSz, resSz prometheus.Summary - router *gin.Engine - listenAddress string - Ppg PrometheusPushGateway - - MetricsList []*Metric - MetricsPath string - - ReqCntURLLabelMappingFn RequestCounterURLLabelMappingFn -} - -// PrometheusPushGateway contains the configuration for pushing to a Prometheus pushgateway (optional) -type PrometheusPushGateway struct { - - // Push interval in seconds - PushIntervalSeconds time.Duration - - // Push Gateway URL in format http://domain:port - // where JOBNAME can be any string of your choice - PushGatewayURL string - - // Local metrics URL where metrics are fetched from, this could be ommited in the future - // if implemented using prometheus common/expfmt instead - MetricsURL string - - // pushgateway job name, defaults to "gin" - Job string -} - -// NewPrometheus generates a new set of metrics with a certain subsystem name -func NewPrometheus(subsystem string, customMetricsList ...[]*Metric) *Prometheus { - - var metricsList []*Metric - - if len(customMetricsList) > 1 { - panic("Too many args. NewPrometheus( string, ).") - } else if len(customMetricsList) == 1 { - metricsList = customMetricsList[0] - } - - for _, metric := range standardMetrics { - metricsList = append(metricsList, metric) - } - - p := &Prometheus{ - MetricsList: metricsList, - MetricsPath: defaultMetricPath, - ReqCntURLLabelMappingFn: func(c *gin.Context) string { - return c.Request.URL.String() // i.e. by default do nothing, i.e. return URL as is - }, - } - - p.registerMetrics(subsystem) - - return p -} - -// SetPushGateway sends metrics to a remote pushgateway exposed on pushGatewayURL -// every pushIntervalSeconds. Metrics are fetched from metricsURL -func (p *Prometheus) SetPushGateway(pushGatewayURL, metricsURL string, pushIntervalSeconds time.Duration) { - p.Ppg.PushGatewayURL = pushGatewayURL - p.Ppg.MetricsURL = metricsURL - p.Ppg.PushIntervalSeconds = pushIntervalSeconds - p.startPushTicker() -} - -// SetPushGatewayJob job name, defaults to "gin" -func (p *Prometheus) SetPushGatewayJob(j string) { - p.Ppg.Job = j -} - -// SetListenAddress for exposing metrics on address. If not set, it will be exposed at the -// same address of the gin engine that is being used -func (p *Prometheus) SetListenAddress(address string) { - p.listenAddress = address - if p.listenAddress != "" { - p.router = gin.Default() - } -} - -// SetListenAddressWithRouter for using a separate router to expose metrics. (this keeps things like GET /metrics out of -// your content's access log). -func (p *Prometheus) SetListenAddressWithRouter(listenAddress string, r *gin.Engine) { - p.listenAddress = listenAddress - if len(p.listenAddress) > 0 { - p.router = r - } -} - -func (p *Prometheus) setMetricsPath(e *gin.Engine) { - - if p.listenAddress != "" { - p.router.GET(p.MetricsPath, prometheusHandler()) - p.runServer() - } else { - e.GET(p.MetricsPath, prometheusHandler()) - } -} - -func (p *Prometheus) setMetricsPathWithAuth(e *gin.Engine, accounts gin.Accounts) { - - if p.listenAddress != "" { - p.router.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler()) - p.runServer() - } else { - e.GET(p.MetricsPath, gin.BasicAuth(accounts), prometheusHandler()) - } - -} - -func (p *Prometheus) runServer() { - if p.listenAddress != "" { - go p.router.Run(p.listenAddress) - } -} - -func (p *Prometheus) getMetrics() []byte { - response, _ := http.Get(p.Ppg.MetricsURL) - - defer response.Body.Close() - body, _ := ioutil.ReadAll(response.Body) - - return body -} - -func (p *Prometheus) getPushGatewayURL() string { - h, _ := os.Hostname() - if p.Ppg.Job == "" { - p.Ppg.Job = "gin" - } - return p.Ppg.PushGatewayURL + "/metrics/job/" + p.Ppg.Job + "/instance/" + h -} - -func (p *Prometheus) sendMetricsToPushGateway(metrics []byte) { - req, err := http.NewRequest("POST", p.getPushGatewayURL(), bytes.NewBuffer(metrics)) - client := &http.Client{} - if _, err = client.Do(req); err != nil { - log.WithError(err).Errorln("Error sending to push gateway") - } -} - -func (p *Prometheus) startPushTicker() { - ticker := time.NewTicker(time.Second * p.Ppg.PushIntervalSeconds) - go func() { - for range ticker.C { - p.sendMetricsToPushGateway(p.getMetrics()) - } - }() -} - -// NewMetric associates prometheus.Collector based on Metric.Type -func NewMetric(m *Metric, subsystem string) prometheus.Collector { - var metric prometheus.Collector - switch m.Type { - case "counter_vec": - metric = prometheus.NewCounterVec( - prometheus.CounterOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - m.Args, - ) - case "counter": - metric = prometheus.NewCounter( - prometheus.CounterOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - ) - case "gauge_vec": - metric = prometheus.NewGaugeVec( - prometheus.GaugeOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - m.Args, - ) - case "gauge": - metric = prometheus.NewGauge( - prometheus.GaugeOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - ) - case "histogram_vec": - metric = prometheus.NewHistogramVec( - prometheus.HistogramOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - m.Args, - ) - case "histogram": - metric = prometheus.NewHistogram( - prometheus.HistogramOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - ) - case "summary_vec": - metric = prometheus.NewSummaryVec( - prometheus.SummaryOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - m.Args, - ) - case "summary": - metric = prometheus.NewSummary( - prometheus.SummaryOpts{ - Subsystem: subsystem, - Name: m.Name, - Help: m.Description, - }, - ) - } - return metric -} - -func (p *Prometheus) registerMetrics(subsystem string) { - - for _, metricDef := range p.MetricsList { - metric := NewMetric(metricDef, subsystem) - if err := prometheus.Register(metric); err != nil { - log.WithError(err).Errorf("%s could not be registered in Prometheus", metricDef.Name) - } - switch metricDef { - case reqCnt: - p.reqCnt = metric.(*prometheus.CounterVec) - case reqDur: - p.reqDur = metric.(prometheus.Summary) - case resSz: - p.resSz = metric.(prometheus.Summary) - case reqSz: - p.reqSz = metric.(prometheus.Summary) - } - metricDef.MetricCollector = metric - } -} - -// Use adds the middleware to a gin engine. -func (p *Prometheus) Use(e *gin.Engine) { - e.Use(p.handlerFunc()) - p.setMetricsPath(e) -} - -// UseWithAuth adds the middleware to a gin engine with BasicAuth. -func (p *Prometheus) UseWithAuth(e *gin.Engine, accounts gin.Accounts) { - e.Use(p.handlerFunc()) - p.setMetricsPathWithAuth(e, accounts) -} - -func (p *Prometheus) handlerFunc() gin.HandlerFunc { - return func(c *gin.Context) { - if c.Request.URL.String() == p.MetricsPath { - c.Next() - return - } - - start := time.Now() - reqSz := computeApproximateRequestSize(c.Request) - - c.Next() - - status := strconv.Itoa(c.Writer.Status()) - elapsed := float64(time.Since(start)) / float64(time.Second) - resSz := float64(c.Writer.Size()) - - p.reqDur.Observe(elapsed) - url := p.ReqCntURLLabelMappingFn(c) - p.reqCnt.WithLabelValues(status, c.Request.Method, c.HandlerName(), c.Request.Host, url).Inc() - p.reqSz.Observe(float64(reqSz)) - p.resSz.Observe(resSz) - } -} - -func prometheusHandler() gin.HandlerFunc { - h := promhttp.Handler() - return func(c *gin.Context) { - h.ServeHTTP(c.Writer, c.Request) - } -} - -// From https://github.com/DanielHeckrath/gin-prometheus/blob/master/gin_prometheus.go -func computeApproximateRequestSize(r *http.Request) int { - s := 0 - if r.URL != nil { - s = len(r.URL.String()) - } - - s += len(r.Method) - s += len(r.Proto) - for name, values := range r.Header { - s += len(name) - for _, value := range values { - s += len(value) - } - } - s += len(r.Host) - - // N.B. r.Form and r.MultipartForm are assumed to be included in r.URL. - - if r.ContentLength != -1 { - s += int(r.ContentLength) - } - return s -} diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index e8a29a4..252b84c 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -84,15 +84,15 @@ func (p *Date) UnmarshalJSON(text []byte) (err error) { // TV is the root element. type TV struct { - XMLName xml.Name `xml:"tv" json:"-"` - Channels []Channel `xml:"channel" json:"channels"` - Programmes []Programme `xml:"programme" json:"programmes"` - Date string `xml:"date,attr,omitempty" json:"date,omitempty"` - SourceInfoURL string `xml:"source-info-url,attr,omitempty" json:"source_info_url,omitempty"` - SourceInfoName string `xml:"source-info-name,attr,omitempty" json:"source_info_name,omitempty"` - SourceDataURL string `xml:"source-data-url,attr,omitempty" json:"source_data_url,omitempty"` - GeneratorInfoName string `xml:"generator-info-name,attr,omitempty" json:"generator_info_name,omitempty"` - GeneratorInfoURL string `xml:"generator-info-url,attr,omitempty" json:"generator_info_url,omitempty"` + XMLName xml.Name `xml:"tv" json:"-" db:"-"` + Channels []Channel `xml:"channel" json:"channels" db:"channels"` + Programmes []Programme `xml:"programme" json:"programmes" db:"programmes"` + Date string `xml:"date,attr,omitempty" json:"date,omitempty" db:"date,omitempty"` + SourceInfoURL string `xml:"source-info-url,attr,omitempty" json:"sourceInfoURL,omitempty" db:"source_info_url,omitempty"` + SourceInfoName string `xml:"source-info-name,attr,omitempty" json:"sourceInfoName,omitempty" db:"source_info_name,omitempty"` + SourceDataURL string `xml:"source-data-url,attr,omitempty" json:"sourceDataURL,omitempty" db:"source_data_url,omitempty"` + GeneratorInfoName string `xml:"generator-info-name,attr,omitempty" json:"generatorInfoName,omitempty" db:"generator_info_name,omitempty"` + GeneratorInfoURL string `xml:"generator-info-url,attr,omitempty" json:"generatorInfoURL,omitempty" db:"generator_info_url,omitempty"` } // LoadXML loads the XMLTV XML from file. @@ -110,57 +110,54 @@ func (t *TV) LoadXML(f *os.File) error { // Channel details of a channel type Channel struct { - DisplayNames []CommonElement `xml:"display-name" json:"display_names" ` - Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` - URLs []string `xml:"url,omitempty" json:"urls,omitempty" ` - ID string `xml:"id,attr" json:"id,omitempty" ` - - // These fields are outside of the XMLTV spec. - // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. - LCN int `xml:"lcn" json:"lcn,omitempty"` + DisplayNames []CommonElement `xml:"display-name" json:"displayNames" db:"display_names" ` + Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty" db:"icons,omitempty"` + URLs []string `xml:"url,omitempty" json:"urls,omitempty" db:"urls,omitempty" ` + ID string `xml:"id,attr" json:"id,omitempty" db:"id,omitempty" ` + LCN int `xml:"lcn" json:"lcn,omitempty" db:"lcn,omitempty"` // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. } // Programme details of a single programme transmission type Programme struct { - ID string `xml:"id,attr,omitempty" json:"id,omitempty"` // not defined by standard, but often present - Titles []CommonElement `xml:"title" json:"titles"` - SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondary_titles,omitempty"` - Descriptions []CommonElement `xml:"desc,omitempty" json:"descriptions,omitempty"` - Credits *Credits `xml:"credits,omitempty" json:"credits,omitempty"` - Date Date `xml:"date,omitempty" json:"date,omitempty"` - Categories []CommonElement `xml:"category,omitempty" json:"categories,omitempty"` - Keywords []CommonElement `xml:"keyword,omitempty" json:"keywords,omitempty"` - Languages []CommonElement `xml:"language,omitempty" json:"languages,omitempty"` - OrigLanguages []CommonElement `xml:"orig-language,omitempty" json:"orig_languages,omitempty"` - Length *Length `xml:"length,omitempty" json:"length,omitempty"` - Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` - URLs []string `xml:"url,omitempty" json:"urls,omitempty"` - Countries []CommonElement `xml:"country,omitempty" json:"countries,omitempty"` - EpisodeNums []EpisodeNum `xml:"episode-num,omitempty" json:"episode_nums,omitempty"` - Video *Video `xml:"video,omitempty" json:"video,omitempty"` - Audio *Audio `xml:"audio,omitempty" json:"audio,omitempty"` - PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previously_shown,omitempty"` - Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty"` - LastChance *CommonElement `xml:"last-chance,omitempty" json:"last_chance,omitempty"` - New *ElementPresent `xml:"new" json:"new,omitempty"` - Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty"` - Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty"` - StarRatings []Rating `xml:"star-rating,omitempty" json:"star_ratings,omitempty"` - Reviews []Review `xml:"review,omitempty" json:"reviews,omitempty"` - Start *Time `xml:"start,attr" json:"start"` - Stop *Time `xml:"stop,attr,omitempty" json:"stop,omitempty"` - PDCStart *Time `xml:"pdc-start,attr,omitempty" json:"pdc_start,omitempty"` - VPSStart *Time `xml:"vps-start,attr,omitempty" json:"vps_start,omitempty"` - Showview string `xml:"showview,attr,omitempty" json:"showview,omitempty"` - Videoplus string `xml:"videoplus,attr,omitempty" json:"videoplus,omitempty"` - Channel string `xml:"channel,attr" json:"channel"` - Clumpidx string `xml:"clumpidx,attr,omitempty" json:"clumpidx,omitempty"` + ID string `xml:"id,attr,omitempty" json:"id,omitempty" db:"id,omitempty"` // not defined by standard, but often present + Titles []CommonElement `xml:"title" json:"titles" db:"titles"` + SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondaryTitles,omitempty" db:"secondary_titles,omitempty"` + Descriptions []CommonElement `xml:"desc,omitempty" json:"descriptions,omitempty" db:"descriptions,omitempty"` + Credits *Credits `xml:"credits,omitempty" json:"credits,omitempty" db:"credits,omitempty"` + Date Date `xml:"date,omitempty" json:"date,omitempty" db:"date,omitempty"` + Categories []CommonElement `xml:"category,omitempty" json:"categories,omitempty" db:"categories,omitempty"` + Keywords []CommonElement `xml:"keyword,omitempty" json:"keywords,omitempty" db:"keywords,omitempty"` + Languages []CommonElement `xml:"language,omitempty" json:"languages,omitempty" db:"languages,omitempty"` + OrigLanguages []CommonElement `xml:"orig-language,omitempty" json:"origLanguages,omitempty" db:"orig_languages,omitempty"` + Length *Length `xml:"length,omitempty" json:"length,omitempty" db:"length,omitempty"` + Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty" db:"icons,omitempty"` + URLs []string `xml:"url,omitempty" json:"urls,omitempty" db:"urls,omitempty"` + Countries []CommonElement `xml:"country,omitempty" json:"countries,omitempty" db:"countries,omitempty"` + EpisodeNums []EpisodeNum `xml:"episode-num,omitempty" json:"episodeNums,omitempty" db:"episode_nums,omitempty"` + Video *Video `xml:"video,omitempty" json:"video,omitempty" db:"video,omitempty"` + Audio *Audio `xml:"audio,omitempty" json:"audio,omitempty" db:"audio,omitempty"` + PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previouslyShown,omitempty" db:"previously_shown,omitempty"` + Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty" db:"premiere,omitempty"` + LastChance *CommonElement `xml:"last-chance,omitempty" json:"lastChance,omitempty" db:"last_chance,omitempty"` + New *ElementPresent `xml:"new" json:"new,omitempty" db:"new,omitempty"` + Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty" db:"subtitles,omitempty"` + Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty" db:"ratings,omitempty"` + StarRatings []Rating `xml:"star-rating,omitempty" json:"starRatings,omitempty" db:"star_ratings,omitempty"` + Reviews []Review `xml:"review,omitempty" json:"reviews,omitempty" db:"reviews,omitempty"` + Start *Time `xml:"start,attr" json:"start" db:"start"` + Stop *Time `xml:"stop,attr,omitempty" json:"stop,omitempty" db:"stop,omitempty"` + PDCStart *Time `xml:"pdc-start,attr,omitempty" json:"pdcStart,omitempty" db:"pdc_start,omitempty"` + VPSStart *Time `xml:"vps-start,attr,omitempty" json:"vpsStart,omitempty" db:"vps_start,omitempty"` + Showview string `xml:"showview,attr,omitempty" json:"showview,omitempty" db:"showview,omitempty"` + Videoplus string `xml:"videoplus,attr,omitempty" json:"videoplus,omitempty" db:"videoplus,omitempty"` + Channel string `xml:"channel,attr" json:"channel" db:"channel"` + Clumpidx string `xml:"clumpidx,attr,omitempty" json:"clumpidx,omitempty" db:"clumpidx,omitempty"` } // CommonElement element structure that is common, i.e. Italy type CommonElement struct { - Lang string `xml:"lang,attr,omitempty" json:"lang,omitempty" ` - Value string `xml:",chardata" json:"value,omitempty"` + Lang string `xml:"lang,attr,omitempty" json:"lang,omitempty" db:"lang,omitempty" ` + Value string `xml:",chardata" json:"value,omitempty" db:"value,omitempty"` } // ElementPresent used to determine if element is present or not @@ -186,81 +183,81 @@ func (c *ElementPresent) UnmarshalXML(d *xml.Decoder, start xml.StartElement) er // Icon associated with the element that contains it type Icon struct { - Source string `xml:"src,attr" json:"source"` - Width int `xml:"width,attr,omitempty" json:"width,omitempty"` - Height int `xml:"height,attr,omitempty" json:"height,omitempty"` + Source string `xml:"src,attr" json:"source" db:"source"` + Width int `xml:"width,attr,omitempty" json:"width,omitempty" db:"width,omitempty"` + Height int `xml:"height,attr,omitempty" json:"height,omitempty" db:"height,omitempty"` } // Credits for the programme type Credits struct { - Directors []string `xml:"director,omitempty" json:"directors,omitempty"` - Actors []Actor `xml:"actor,omitempty" json:"actors,omitempty"` - Writers []string `xml:"writer,omitempty" json:"writers,omitempty"` - Adapters []string `xml:"adapter,omitempty" json:"adapters,omitempty"` - Producers []string `xml:"producer,omitempty" json:"producers,omitempty"` - Composers []string `xml:"composer,omitempty" json:"composers,omitempty"` - Editors []string `xml:"editor,omitempty" json:"editors,omitempty"` - Presenters []string `xml:"presenter,omitempty" json:"presenters,omitempty"` - Commentators []string `xml:"commentator,omitempty" json:"commentators,omitempty"` - Guests []string `xml:"guest,omitempty" json:"guests,omitempty"` + Directors []string `xml:"director,omitempty" json:"directors,omitempty" db:"directors,omitempty"` + Actors []Actor `xml:"actor,omitempty" json:"actors,omitempty" db:"actors,omitempty"` + Writers []string `xml:"writer,omitempty" json:"writers,omitempty" db:"writers,omitempty"` + Adapters []string `xml:"adapter,omitempty" json:"adapters,omitempty" db:"adapters,omitempty"` + Producers []string `xml:"producer,omitempty" json:"producers,omitempty" db:"producers,omitempty"` + Composers []string `xml:"composer,omitempty" json:"composers,omitempty" db:"composers,omitempty"` + Editors []string `xml:"editor,omitempty" json:"editors,omitempty" db:"editors,omitempty"` + Presenters []string `xml:"presenter,omitempty" json:"presenters,omitempty" db:"presenters,omitempty"` + Commentators []string `xml:"commentator,omitempty" json:"commentators,omitempty" db:"commentators,omitempty"` + Guests []string `xml:"guest,omitempty" json:"guests,omitempty" db:"guests,omitempty"` } // Actor in a programme type Actor struct { - Role string `xml:"role,attr,omitempty" json:"role,omitempty"` - Value string `xml:",chardata" json:"value"` + Role string `xml:"role,attr,omitempty" json:"role,omitempty" db:"role,omitempty"` + Value string `xml:",chardata" json:"value" db:"value"` } // Length of the programme type Length struct { - Units string `xml:"units,attr" json:"units"` - Value string `xml:",chardata" json:"value"` + Units string `xml:"units,attr" json:"units" db:"units"` + Value string `xml:",chardata" json:"value" db:"value"` } // EpisodeNum of the programme type EpisodeNum struct { - System string `xml:"system,attr,omitempty" json:"system,omitempty"` - Value string `xml:",chardata" json:"value"` + System string `xml:"system,attr,omitempty" json:"system,omitempty" db:"system,omitempty"` + Value string `xml:",chardata" json:"value" db:"value"` } // Video details of the programme type Video struct { - Present string `xml:"present,omitempty" json:"present,omitempty"` - Colour string `xml:"colour,omitempty" json:"colour,omitempty"` - Aspect string `xml:"aspect,omitempty" json:"aspect,omitempty"` - Quality string `xml:"quality,omitempty" json:"quality,omitempty"` + Present string `xml:"present,omitempty" json:"present,omitempty" db:"present,omitempty"` + Colour string `xml:"colour,omitempty" json:"colour,omitempty" db:"colour,omitempty"` + Aspect string `xml:"aspect,omitempty" json:"aspect,omitempty" db:"aspect,omitempty"` + Quality string `xml:"quality,omitempty" json:"quality,omitempty" db:"quality,omitempty"` } // Audio details of the programme type Audio struct { - Present string `xml:"present,omitempty" json:"present,omitempty"` - Stereo string `xml:"stereo,omitempty" json:"stereo,omitempty"` + Present string `xml:"present,omitempty" json:"present,omitempty" db:"present,omitempty"` + Stereo string `xml:"stereo,omitempty" json:"stereo,omitempty" db:"stereo,omitempty"` } // PreviouslyShown When and where the programme was last shown, if known. type PreviouslyShown struct { - Start string `xml:"start,attr,omitempty" json:"start,omitempty"` - Channel string `xml:"channel,attr,omitempty" json:"channel,omitempty"` + Start string `xml:"start,attr,omitempty" json:"start,omitempty" db:"start,omitempty"` + Channel string `xml:"channel,attr,omitempty" json:"channel,omitempty" db:"channel,omitempty"` } // Subtitle in a programme type Subtitle struct { - Language *CommonElement `xml:"language,omitempty" json:"language,omitempty"` - Type string `xml:"type,attr,omitempty" json:"type,omitempty"` + Language *CommonElement `xml:"language,omitempty" json:"language,omitempty" db:"language,omitempty"` + Type string `xml:"type,attr,omitempty" json:"type,omitempty" db:"type,omitempty"` } // Rating of a programme type Rating struct { - Value string `xml:"value" json:"value"` - Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty"` - System string `xml:"system,attr,omitempty" json:"system,omitempty"` + Value string `xml:"value" json:"value" db:"value"` + Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty" db:"icons,omitempty"` + System string `xml:"system,attr,omitempty" json:"system,omitempty" db:"system,omitempty"` } // Review of a programme type Review struct { - Value string `xml:",chardata" json:"value"` - Type string `xml:"type" json:"type"` - Source string `xml:"source,omitempty" json:"source,omitempty"` - Reviewer string `xml:"reviewer,omitempty" json:"reviewer,omitempty"` - Lang string `xml:"lang,omitempty" json:"lang,omitempty"` + Value string `xml:",chardata" json:"value" db:"value"` + Type string `xml:"type" json:"type" db:"type"` + Source string `xml:"source,omitempty" json:"source,omitempty" db:"source,omitempty"` + Reviewer string `xml:"reviewer,omitempty" json:"reviewer,omitempty" db:"reviewer,omitempty"` + Lang string `xml:"lang,omitempty" json:"lang,omitempty" db:"lang,omitempty"` } diff --git a/main.go b/main.go index 2e4d6f2..710961a 100644 --- a/main.go +++ b/main.go @@ -7,13 +7,14 @@ import ( "net" "os" "regexp" - "strings" "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/common/version" "github.com/sirupsen/logrus" flag "github.com/spf13/pflag" "github.com/spf13/viper" + "github.com/tellytv/telly/api" + "github.com/tellytv/telly/context" ) var ( @@ -34,23 +35,6 @@ var ( Help: "Number of exposed channels.", }, ) - - safeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) - - stringSafer = func(input string) string { - ret := input - if strings.HasPrefix(input, "username=") { - ret = "username=REDACTED" - } else if strings.HasPrefix(input, "password=") { - ret = "password=REDACTED" - } else if strings.HasPrefix(input, "token=") { - ret = "token=bm90Zm9yeW91" // "notforyou" - } - if strings.HasSuffix(input, "&") { - return fmt.Sprintf("%s&", ret) - } - return ret - } ) func main() { @@ -164,13 +148,12 @@ func main() { log.Debugf("Loaded configuration %s", js) } - lineup := newLineup() - - if scanErr := lineup.Scan(); scanErr != nil { - log.WithError(scanErr).Panicln("Error scanning lineup!") + cc, err := context.NewCContext() + if err != nil { + log.Fatalln("Couldn't create context", err) } - serve(lineup) + api.ServeAPI(cc) } func validateConfig() { diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql new file mode 100644 index 0000000..7dda913 --- /dev/null +++ b/migrations/00001_init.sql @@ -0,0 +1,77 @@ +-- +goose Up +-- SQL in this section is executed when the migration is applied. + +CREATE TABLE IF NOT EXISTS video_source ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + provider VARCHAR(64) NULL, + username VARCHAR(64) NULL, + password VARCHAR(64) NULL, + m3u_url TEXT, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS video_source_track ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + video_source_id INTEGER, + name TEXT, + tags TEXT, + raw_line TEXT, + stream_url TEXT, + hd BOOLEAN, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + + FOREIGN KEY(video_source_id) REFERENCES video_source(id) +); + +CREATE TABLE IF NOT EXISTS guide_source ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + provider VARCHAR(64) NULL, + username VARCHAR(64) NULL, + password VARCHAR(64) NULL, + xmltv_url TEXT, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS guide_source_channel ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + guide_id INTEGER, + xmltv_id TEXT, + display_names TEXT, + urls TEXT, + icons TEXT, + channel_number TEXT, + hd BOOLEAN, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + + FOREIGN KEY(guide_id) REFERENCES guide_source(id) +); + +CREATE TABLE IF NOT EXISTS lineup ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + +CREATE TABLE IF NOT EXISTS lineup_channel ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + title TEXT, + channel_number TEXT, + video_track_id INTEGER, + guide_channel_id TEXT, + hd BOOLEAN, + favorite BOOLEAN, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP +); + + +-- +goose Down +-- SQL in this section is executed when the migration is rolled back. + +DROP TABLE video_source; +DROP TABLE video_source_track; +DROP TABLE guide_source; +DROP TABLE guide_source_channel; +DROP TABLE lineup; +DROP TABLE lineup_channel; diff --git a/models/guide_source.go b/models/guide_source.go new file mode 100644 index 0000000..449c760 --- /dev/null +++ b/models/guide_source.go @@ -0,0 +1,129 @@ +package models + +import ( + "fmt" + "time" + + "github.com/jmoiron/sqlx" + "github.com/tellytv/telly/internal/providers" +) + +// GuideSourceDB is a struct containing initialized the SQL connection as well as the APICollection. +type GuideSourceDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newGuideSourceDB( + SQL *sqlx.DB, + Collection *APICollection, +) *GuideSourceDB { + db := &GuideSourceDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *GuideSourceDB) tableName() string { + return "guide_source" +} + +type GuideSource struct { + ID int `db:"id" json:"id"` + Name string `db:"name" json:"name"` + Provider string `db:"provider" json:"provider"` + Username string `db:"username" json:"username"` + Password string `db:"password" json:"password"` + URL string `db:"xmltv_url" json:"url"` + ImportedAt *time.Time `db:"imported_at" json:"importedAt"` + + Channels []GuideSourceChannel `db:"-" json:"channels"` +} + +func (g *GuideSource) ProviderConfiguration() *providers.Configuration { + return &providers.Configuration{ + Name: g.Name, + Provider: g.Provider, + Username: g.Username, + Password: g.Password, + EPG: g.URL, + } +} + +// GuideSourceAPI contains all methods for the User struct +type GuideSourceAPI interface { + InsertGuideSource(guideSourceStruct GuideSource) (*GuideSource, error) + DeleteGuideSource(guideSourceID string) (*GuideSource, error) + UpdateGuideSource(guideSourceID, description string) (*GuideSource, error) + GetGuideSourceByID(id string) (*GuideSource, error) + GetAllGuideSources(includeChannels bool) ([]GuideSource, error) +} + +const baseGuideSourceQuery string = ` +SELECT + G.id, + G.name, + G.provider, + G.username, + G.password, + G.xmltv_url, + G.imported_at + FROM guide_source G` + +// InsertGuideSource inserts a new GuideSource into the database. +func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource) (*GuideSource, error) { + guideSource := GuideSource{} + res, err := db.SQL.NamedExec(` + INSERT INTO guide_source (name, provider, username, password, xmltv_url) + VALUES (:name, :provider, :username, :password, :xmltv_url);`, guideSourceStruct) + if err != nil { + return &guideSource, err + } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return &guideSource, rowIDErr + } + err = db.SQL.Get(&guideSource, "SELECT * FROM guide_source WHERE id = $1", rowID) + return &guideSource, err +} + +// GetGuideSourceByID returns a single GuideSource for the given ID. +func (db *GuideSourceDB) GetGuideSourceByID(id string) (*GuideSource, error) { + var guideSource GuideSource + err := db.SQL.Get(&guideSource, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceQuery), id) + return &guideSource, err +} + +// DeleteGuideSource marks a guideSource with the given ID as deleted. +func (db *GuideSourceDB) DeleteGuideSource(guideSourceID string) (*GuideSource, error) { + guideSource := GuideSource{} + err := db.SQL.Get(&guideSource, `DELETE FROM guide_source WHERE id = $1`, guideSourceID) + return &guideSource, err +} + +// UpdateGuideSource updates a guideSource. +func (db *GuideSourceDB) UpdateGuideSource(guideSourceID, description string) (*GuideSource, error) { + guideSource := GuideSource{} + err := db.SQL.Get(&guideSource, `UPDATE guide_source SET description = $2 WHERE id = $1 RETURNING *`, guideSourceID, description) + return &guideSource, err +} + +// GetAllGuideSources returns all video sources in the database. +func (db *GuideSourceDB) GetAllGuideSources(includeChannels bool) ([]GuideSource, error) { + sources := make([]GuideSource, 0) + err := db.SQL.Select(&sources, baseGuideSourceQuery) + if includeChannels { + newSources := make([]GuideSource, 0) + for _, source := range sources { + allChannels, channelsErr := db.Collection.GuideSourceChannel.GetChannelsForGuideSource(source.ID) + if channelsErr != nil { + return nil, channelsErr + } + source.Channels = append(source.Channels, allChannels...) + newSources = append(newSources, source) + } + return newSources, nil + } + return sources, err +} diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go new file mode 100644 index 0000000..d2a55a9 --- /dev/null +++ b/models/guide_source_channel.go @@ -0,0 +1,109 @@ +package models + +import ( + "encoding/json" + "fmt" + "time" + + "github.com/jmoiron/sqlx" +) + +// GuideSourceChannelDB is a struct containing initialized the SQL connection as well as the APICollection. +type GuideSourceChannelDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newGuideSourceChannelDB( + SQL *sqlx.DB, + Collection *APICollection, +) *GuideSourceChannelDB { + db := &GuideSourceChannelDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *GuideSourceChannelDB) tableName() string { + return "guide_source_channel" +} + +type GuideSourceChannel struct { + ID int `db:"id" json:"id"` + GuideID int `db:"guide_id" json:"guideID"` + XMLTVID string `db:"xmltv_id" json:"xmltvID"` + DisplayNames json.RawMessage `db:"display_names" json:"displayNames"` + URLs json.RawMessage `db:"urls" json:"urls"` + Icons json.RawMessage `db:"icons" json:"icons"` + ChannelNumber string `db:"channel_number" json:"channelNumber"` + HighDefinition bool `db:"hd" json:"hd"` + ImportedAt *time.Time `db:"imported_at" json:"importedAt"` +} + +// GuideSourceChannelAPI contains all methods for the User struct +type GuideSourceChannelAPI interface { + InsertGuideSourceChannel(channelStruct GuideSourceChannel) (*GuideSourceChannel, error) + DeleteGuideSourceChannel(channelID string) (*GuideSourceChannel, error) + UpdateGuideSourceChannel(channelID, description string) (*GuideSourceChannel, error) + GetGuideSourceChannelByID(id string) (*GuideSourceChannel, error) + GetChannelsForGuideSource(guideSourceID int) ([]GuideSourceChannel, error) +} + +const baseGuideSourceChannelQuery string = ` +SELECT + G.id, + G.guide_id, + G.xmltv_id, + G.display_names, + G.urls, + G.icons, + G.channel_number, + G.hd, + G.imported_at + FROM guide_source_channel G` + +// InsertGuideSourceChannel inserts a new GuideSourceChannel into the database. +func (db *GuideSourceChannelDB) InsertGuideSourceChannel(channelStruct GuideSourceChannel) (*GuideSourceChannel, error) { + channel := GuideSourceChannel{} + res, err := db.SQL.NamedExec(` + INSERT INTO guide_source_channel (guide_id, xmltv_id, display_names, urls, icons, channel_number, hd) + VALUES (:guide_id, :xmltv_id, :display_names, :urls, :icons, :channel_number, :hd)`, channelStruct) + if err != nil { + return &channel, err + } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return &channel, rowIDErr + } + err = db.SQL.Get(&channel, "SELECT * FROM guide_source_channel WHERE id = $1", rowID) + return &channel, err +} + +// GetGuideSourceChannelByID returns a single GuideSourceChannel for the given ID. +func (db *GuideSourceChannelDB) GetGuideSourceChannelByID(id string) (*GuideSourceChannel, error) { + var channel GuideSourceChannel + err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceChannelQuery), id) + return &channel, err +} + +// DeleteGuideSourceChannel marks a channel with the given ID as deleted. +func (db *GuideSourceChannelDB) DeleteGuideSourceChannel(channelID string) (*GuideSourceChannel, error) { + channel := GuideSourceChannel{} + err := db.SQL.Get(&channel, `DELETE FROM guide_source_channel WHERE id = $1`, channelID) + return &channel, err +} + +// UpdateGuideSourceChannel updates a channel. +func (db *GuideSourceChannelDB) UpdateGuideSourceChannel(channelID, description string) (*GuideSourceChannel, error) { + channel := GuideSourceChannel{} + err := db.SQL.Get(&channel, `UPDATE guide_source_channel SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) + return &channel, err +} + +// GetChannelsForGuideSource returns a slice of GuideSourceChannels for the given video source ID. +func (db *GuideSourceChannelDB) GetChannelsForGuideSource(guideSourceID int) ([]GuideSourceChannel, error) { + channels := make([]GuideSourceChannel, 0) + err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE G.guide_id = $1`, baseGuideSourceChannelQuery), guideSourceID) + return channels, err +} diff --git a/models/lineup.go b/models/lineup.go new file mode 100644 index 0000000..662b7b5 --- /dev/null +++ b/models/lineup.go @@ -0,0 +1,92 @@ +package models + +import ( + "fmt" + "time" + + "github.com/jmoiron/sqlx" +) + +// LineupDB is a struct containing initialized the SQL connection as well as the APICollection. +type LineupDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newLineupDB( + SQL *sqlx.DB, + Collection *APICollection, +) *LineupDB { + db := &LineupDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *LineupDB) tableName() string { + return "lineup" +} + +type SQLLineup struct { + ID int `db:"id"` + Name string `db:"name"` + ChannelsStr string `db:"channels"` + CreatedAt *time.Time `db:"created_at"` +} + +// LineupAPI contains all methods for the User struct +type LineupAPI interface { + InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) + DeleteLineup(lineupID string) (*SQLLineup, error) + UpdateLineup(lineupID, description string) (*SQLLineup, error) + GetLineupByID(id string) (*SQLLineup, error) +} + +const baseLineupQuery string = ` +SELECT + L.id, + L.name, + L.channels, + L.created_at + FROM lineups L` + +// InsertLineup inserts a new Lineup into the database. +func (db *LineupDB) InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) { + lineup := SQLLineup{} + rows, err := db.SQL.NamedQuery(` + INSERT INTO lineups (name, channels, created_at) + VALUES (name, :channels, :created_at) + RETURNING *`, lineupStruct) + if err != nil { + return &lineup, err + } + for rows.Next() { + err := rows.StructScan(&lineup) + if err != nil { + return &lineup, err + } + } + return &lineup, nil +} + +// GetLineupByID returns a single Lineup for the given ID. +func (db *LineupDB) GetLineupByID(id string) (*SQLLineup, error) { + var lineup SQLLineup + err := db.SQL.Get(&lineup, fmt.Sprintf(`%s WHERE L.id = $1`, baseLineupQuery), id) + return &lineup, err +} + +// DeleteLineup marks a lineup with the given ID as deleted. +func (db *LineupDB) DeleteLineup(lineupID string) (*SQLLineup, error) { + lineup := SQLLineup{} + err := db.SQL.Get(&lineup, `DELETE FROM lineups WHERE id = $1`, lineupID) + return &lineup, err +} + +// UpdateLineup updates a lineup. +func (db *LineupDB) UpdateLineup(lineupID, description string) (*SQLLineup, error) { + lineup := SQLLineup{} + err := db.SQL.Get(&lineup, `UPDATE lineups SET description = $2 WHERE id = $1 RETURNING *`, lineupID, description) + return &lineup, err +} diff --git a/models/lineup_channel.go b/models/lineup_channel.go new file mode 100644 index 0000000..092fd76 --- /dev/null +++ b/models/lineup_channel.go @@ -0,0 +1,100 @@ +package models + +import ( + "fmt" + "time" + + "github.com/jmoiron/sqlx" +) + +// LineupChannelDB is a struct containing initialized the SQL connection as well as the APICollection. +type LineupChannelDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newLineupChannelDB( + SQL *sqlx.DB, + Collection *APICollection, +) *LineupChannelDB { + db := &LineupChannelDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *LineupChannelDB) tableName() string { + return "lineup_channels" +} + +type LineupChannel struct { + ID int `db:"id"` + Title string `db:"title"` + ChannelNumber string `db:"channel_number"` + VideoTrackID string `db:"video_track_id"` + GuideChannelID string `db:"guide_channel_id"` + HighDefinition bool `db:"hd"` + Favorite bool `db:"favorite"` + CreatedAt *time.Time `db:"created_at"` +} + +// LineupChannelAPI contains all methods for the User struct +type LineupChannelAPI interface { + InsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) + DeleteLineupChannel(channelID string) (*LineupChannel, error) + UpdateLineupChannel(channelID, description string) (*LineupChannel, error) + GetLineupChannelByID(id string) (*LineupChannel, error) +} + +const baseLineupChannelQuery string = ` +SELECT + C.id, + C.title, + C.channel_number, + C.video_track_id, + C.guide_channel_id, + C.favorite, + C.hd, + C.created_at + FROM lineup_channels C` + +// InsertLineupChannel inserts a new LineupChannel into the database. +func (db *LineupChannelDB) InsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) { + channel := LineupChannel{} + rows, err := db.SQL.NamedQuery(` + INSERT INTO lineup_channels (title, channel_number, video_track_id, guide_channel_id, favorite, hd) + VALUES (:title, :channel_number, :video_track_id, :guide_channel_id, :favorite, :hd) + RETURNING *`, channelStruct) + if err != nil { + return &channel, err + } + for rows.Next() { + err := rows.StructScan(&channel) + if err != nil { + return &channel, err + } + } + return &channel, nil +} + +// GetLineupChannelByID returns a single LineupChannel for the given ID. +func (db *LineupChannelDB) GetLineupChannelByID(id string) (*LineupChannel, error) { + var channel LineupChannel + err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE G.id = $1`, baseLineupChannelQuery), id) + return &channel, err +} + +// DeleteLineupChannel marks a channel with the given ID as deleted. +func (db *LineupChannelDB) DeleteLineupChannel(channelID string) (*LineupChannel, error) { + channel := LineupChannel{} + err := db.SQL.Get(&channel, `DELETE FROM lineup_channels WHERE id = $1`, channelID) + return &channel, err +} + +// UpdateLineupChannel updates a channel. +func (db *LineupChannelDB) UpdateLineupChannel(channelID, description string) (*LineupChannel, error) { + channel := LineupChannel{} + err := db.SQL.Get(&channel, `UPDATE lineup_channels SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) + return &channel, err +} diff --git a/models/main.go b/models/main.go new file mode 100644 index 0000000..e7ae5f5 --- /dev/null +++ b/models/main.go @@ -0,0 +1,63 @@ +package models + +import ( + "context" + "fmt" + "os" + "regexp" + "strings" + + "github.com/jmoiron/sqlx" + "github.com/sirupsen/logrus" +) + +var ( + log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } + + safeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) + + stringSafer = func(input string) string { + ret := input + if strings.HasPrefix(input, "username=") { + ret = "username=REDACTED" + } else if strings.HasPrefix(input, "password=") { + ret = "password=REDACTED" + } else if strings.HasPrefix(input, "token=") { + ret = "token=bm90Zm9yeW91" // "notforyou" + } + if strings.HasSuffix(input, "&") { + return fmt.Sprintf("%s&", ret) + } + return ret + } +) + +// APICollection is a struct containing all models. +type APICollection struct { + GuideSource GuideSourceAPI + GuideSourceChannel GuideSourceChannelAPI + Lineup LineupAPI + LineupChannel LineupChannelAPI + VideoSource VideoSourceAPI + VideoSourceTrack VideoSourceTrackAPI +} + +// NewAPICollection returns an initialized APICollection struct. +func NewAPICollection(ctx context.Context, db *sqlx.DB) *APICollection { + api := &APICollection{} + + api.GuideSource = newGuideSourceDB(db, api) + api.GuideSourceChannel = newGuideSourceChannelDB(db, api) + api.Lineup = newLineupDB(db, api) + api.LineupChannel = newLineupChannelDB(db, api) + api.VideoSource = newVideoSourceDB(db, api) + api.VideoSourceTrack = newVideoSourceTrackDB(db, api) + return api +} diff --git a/lineup.go b/models/old_lineup.go similarity index 91% rename from lineup.go rename to models/old_lineup.go index 8030c12..8f389a8 100644 --- a/lineup.go +++ b/models/old_lineup.go @@ -1,4 +1,4 @@ -package main +package models import ( "compress/gzip" @@ -26,38 +26,37 @@ import ( var xmlNSRegex = regexp.MustCompile(`(\d).(\d).(?:(\d)/(\d))?`) var ddProgIDRegex = regexp.MustCompile(`(?m)(EP|SH|MV|SP)(\d{7,8}).(\d+).?(?:(\d).(\d))?`) -// hdHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. -type hdHomeRunLineupItem struct { - XMLName xml.Name `xml:"Program" json:"-"` - +// HDHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. +type HDHomeRunLineupItem struct { + XMLName xml.Name `xml:"Program" json:"-"` AudioCodec string `xml:",omitempty" json:",omitempty"` - DRM convertibleBoolean `xml:",omitempty" json:",string,omitempty"` - Favorite convertibleBoolean `xml:",omitempty" json:",string,omitempty"` + DRM ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` + Favorite ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` GuideName string `xml:",omitempty" json:",omitempty"` GuideNumber int `xml:",omitempty" json:",string,omitempty"` - HD convertibleBoolean `xml:",omitempty" json:",string,omitempty"` + HD ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` URL string `xml:",omitempty" json:",omitempty"` VideoCodec string `xml:",omitempty" json:",omitempty"` provider providers.Provider - providerChannel providers.ProviderChannel + ProviderChannel providers.ProviderChannel } -func newHDHRItem(provider *providers.Provider, providerChannel *providers.ProviderChannel) hdHomeRunLineupItem { - return hdHomeRunLineupItem{ - DRM: convertibleBoolean(false), - GuideName: providerChannel.Name, - GuideNumber: providerChannel.Number, - Favorite: convertibleBoolean(providerChannel.Favorite), - HD: convertibleBoolean(providerChannel.HD), - URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), providerChannel.Number), +func newHDHRItem(provider *providers.Provider, ProviderChannel *providers.ProviderChannel) HDHomeRunLineupItem { + return HDHomeRunLineupItem{ + DRM: ConvertibleBoolean(false), + GuideName: ProviderChannel.Name, + GuideNumber: ProviderChannel.Number, + Favorite: ConvertibleBoolean(ProviderChannel.Favorite), + HD: ConvertibleBoolean(ProviderChannel.HD), + URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), ProviderChannel.Number), provider: *provider, - providerChannel: *providerChannel, + ProviderChannel: *ProviderChannel, } } -// lineup contains the state of the application. -type lineup struct { +// Lineup contains the state of the application. +type Lineup struct { Sources []providers.Provider Scanning bool @@ -67,13 +66,13 @@ type lineup struct { // If true, use channel numbers found in EPG, if any, before assigning. xmlTVChannelNumbers bool - channels map[int]hdHomeRunLineupItem + Channels map[int]HDHomeRunLineupItem sd *schedulesdirect.Client } -// newLineup returns a new lineup for the given config struct. -func newLineup() *lineup { +// NewLineup returns a new Lineup for the given config struct. +func NewLineup() *Lineup { var cfgs []providers.Configuration if unmarshalErr := viper.UnmarshalKey("source", &cfgs); unmarshalErr != nil { @@ -95,10 +94,10 @@ func newLineup() *lineup { }) } - lineup := &lineup{ + lineup := &Lineup{ assignedChannelNumber: viper.GetInt("iptv.starting-channel"), xmlTVChannelNumbers: viper.GetBool("iptv.xmltv-channels"), - channels: make(map[int]hdHomeRunLineupItem), + Channels: make(map[int]HDHomeRunLineupItem), } if viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") { @@ -123,7 +122,7 @@ func newLineup() *lineup { } // Scan processes all sources. -func (l *lineup) Scan() error { +func (l *Lineup) Scan() error { l.Scanning = true @@ -146,7 +145,7 @@ func (l *lineup) Scan() error { return nil } -func (l *lineup) processProvider(provider providers.Provider) (int, error) { +func (l *Lineup) processProvider(provider providers.Provider) (int, error) { addedChannels := 0 m3u, channelMap, programmeMap, prepareErr := l.prepareProvider(provider) if prepareErr != nil { @@ -182,7 +181,7 @@ func (l *lineup) processProvider(provider providers.Provider) (int, error) { successChannels = append(successChannels, track.Name) } - // Then we do the provider specific translation to a hdHomeRunLineupItem. + // Then we do the provider specific translation to a HDHomeRunLineupItem. channel, channelErr := provider.ParseTrack(track, channelMap) if channelErr != nil { return addedChannels, channelErr @@ -197,7 +196,7 @@ func (l *lineup) processProvider(provider providers.Provider) (int, error) { } addedChannels = addedChannels + 1 - l.channels[channel.Number] = newHDHRItem(&provider, channel) + l.Channels[channel.Number] = newHDHRItem(&provider, channel) } log.Debugf("These channels (%d) passed the filter and successfully parsed: %s", len(successChannels), strings.Join(successChannels, ", ")) @@ -208,10 +207,10 @@ func (l *lineup) processProvider(provider providers.Provider) (int, error) { return addedChannels, nil } -func (l *lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { +func (l *Lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { cacheFiles := provider.Configuration().CacheFiles - reader, m3uErr := getM3U(provider.PlaylistURL(), cacheFiles) + reader, m3uErr := GetM3U(provider.PlaylistURL(), cacheFiles) if m3uErr != nil { log.WithError(m3uErr).Errorln("unable to get m3u file") return nil, nil, nil, m3uErr @@ -236,7 +235,7 @@ func (l *lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, ma return rawPlaylist, channelMap, programmeMap, nil } -func (l *lineup) processProviderChannel(channel *providers.ProviderChannel, programmeMap map[string][]xmltv.Programme) (*providers.ProviderChannel, error) { +func (l *Lineup) processProviderChannel(channel *providers.ProviderChannel, programmeMap map[string][]xmltv.Programme) (*providers.ProviderChannel, error) { if channel.EPGChannel != nil { channel.EPGProgrammes = programmeMap[channel.EPGMatch] } @@ -260,7 +259,7 @@ func (l *lineup) processProviderChannel(channel *providers.ProviderChannel, prog return channel, nil } -func (l *lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool { +func (l *Lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool { config := provider.Configuration() if config.Filter == "" && len(config.IncludeOnly) == 0 { return true @@ -298,13 +297,13 @@ func (l *lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool } -func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { +func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { var epg *xmltv.TV epgChannelMap := make(map[string]xmltv.Channel) epgProgrammeMap := make(map[string][]xmltv.Programme) if provider.EPGURL() != "" { var epgErr error - epg, epgErr = getXMLTV(provider.EPGURL(), cacheFiles) + epg, epgErr = GetXMLTV(provider.EPGURL(), cacheFiles) if epgErr != nil { return epgChannelMap, epgProgrammeMap, epgErr } @@ -455,11 +454,11 @@ func (l *lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s return epgChannelMap, epgProgrammeMap, nil } -func getM3U(path string, cacheFiles bool) (io.ReadCloser, error) { +func GetM3U(path string, cacheFiles bool) (io.ReadCloser, error) { safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) log.Infof("Loading M3U from %s", safePath) - file, _, err := getFile(path, cacheFiles) + file, _, err := GetFile(path, cacheFiles) if err != nil { return nil, err } @@ -467,10 +466,10 @@ func getM3U(path string, cacheFiles bool) (io.ReadCloser, error) { return file, nil } -func getXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { +func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) log.Infof("Loading XMLTV from %s", safePath) - file, _, err := getFile(path, cacheFiles) + file, _, err := GetFile(path, cacheFiles) if err != nil { return nil, err } @@ -489,7 +488,7 @@ func getXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { return tvSetup, nil } -func getFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { +func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { transport := "disk" if strings.HasPrefix(strings.ToLower(path), "http") { diff --git a/models/types.go b/models/types.go new file mode 100644 index 0000000..7e8791a --- /dev/null +++ b/models/types.go @@ -0,0 +1,56 @@ +package models + +import ( + "encoding/json" + "encoding/xml" + "fmt" +) + +type ConvertibleBoolean bool + +func (bit *ConvertibleBoolean) MarshalJSON() ([]byte, error) { + var bitSetVar int8 + if *bit { + bitSetVar = 1 + } + + return json.Marshal(bitSetVar) +} + +func (bit *ConvertibleBoolean) UnmarshalJSON(data []byte) error { + asString := string(data) + if asString == "1" || asString == "true" { + *bit = true + } else if asString == "0" || asString == "false" { + *bit = false + } else { + return fmt.Errorf("Boolean unmarshal error: invalid input %s", asString) + } + return nil +} + +// MarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 +func (bit *ConvertibleBoolean) MarshalXML(e *xml.Encoder, start xml.StartElement) error { + var bitSetVar int8 + if *bit { + bitSetVar = 1 + } + + return e.EncodeElement(bitSetVar, start) +} + +// UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 +func (bit *ConvertibleBoolean) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { + var asString string + if decodeErr := d.DecodeElement(&asString, &start); decodeErr != nil { + return decodeErr + } + if asString == "1" || asString == "true" { + *bit = true + } else if asString == "0" || asString == "false" { + *bit = false + } else { + return fmt.Errorf("Boolean unmarshal error: invalid input %s", asString) + } + return nil +} diff --git a/models/video_source.go b/models/video_source.go new file mode 100644 index 0000000..dc099cb --- /dev/null +++ b/models/video_source.go @@ -0,0 +1,128 @@ +package models + +import ( + "fmt" + "time" + + "github.com/jmoiron/sqlx" + "github.com/tellytv/telly/internal/providers" +) + +// VideoSourceDB is a struct containing initialized the SQL connection as well as the APICollection. +type VideoSourceDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newVideoSourceDB( + SQL *sqlx.DB, + Collection *APICollection, +) *VideoSourceDB { + db := &VideoSourceDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *VideoSourceDB) tableName() string { + return "video_source" +} + +type VideoSource struct { + ID int `db:"id" json:"id,omitempty"` + Name string `db:"name" json:"name,omitempty"` + Provider string `db:"provider" json:"provider,omitempty"` + Username string `db:"username" json:"username,omitempty"` + Password string `db:"password" json:"password,omitempty"` + M3UURL string `db:"m3u_url" json:"m3uURL,omitempty"` + ImportedAt *time.Time `db:"imported_at" json:"importedAt,omitempty"` + + Tracks []VideoSourceTrack `db:"tracks" json:"tracks,omitempty"` +} + +func (v *VideoSource) ProviderConfiguration() *providers.Configuration { + return &providers.Configuration{ + Name: v.Name, + Provider: v.Provider, + Username: v.Username, + Password: v.Password, + M3U: v.M3UURL, + } +} + +// VideoSourceAPI contains all methods for the User struct +type VideoSourceAPI interface { + InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) + DeleteVideoSource(videoSourceID string) (*VideoSource, error) + UpdateVideoSource(videoSourceID, description string) (*VideoSource, error) + GetVideoSourceByID(id string) (*VideoSource, error) + GetAllVideoSources(includeTracks bool) ([]VideoSource, error) +} + +const baseVideoSourceQuery string = ` +SELECT + V.id, + V.name, + V.provider, + V.username, + V.password, + V.imported_at + FROM video_source V` + +// InsertVideoSource inserts a new VideoSource into the database. +func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) { + videoSource := VideoSource{} + res, err := db.SQL.NamedExec(` + INSERT INTO video_source (name, provider, username, password, m3u_url) + VALUES (:name, :provider, :username, :password, :m3u_url);`, videoSourceStruct) + if err != nil { + return &videoSource, err + } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return &videoSource, rowIDErr + } + err = db.SQL.Get(&videoSource, "SELECT * FROM video_source WHERE id = $1", rowID) + return &videoSource, err +} + +// GetVideoSourceByID returns a single VideoSource for the given ID. +func (db *VideoSourceDB) GetVideoSourceByID(id string) (*VideoSource, error) { + var videoSource VideoSource + err := db.SQL.Get(&videoSource, fmt.Sprintf(`%s WHERE V.id = $1`, baseVideoSourceQuery), id) + return &videoSource, err +} + +// DeleteVideoSource marks a videoSource with the given ID as deleted. +func (db *VideoSourceDB) DeleteVideoSource(videoSourceID string) (*VideoSource, error) { + videoSource := VideoSource{} + err := db.SQL.Get(&videoSource, `DELETE FROM video_source WHERE id = $1`, videoSourceID) + return &videoSource, err +} + +// UpdateVideoSource updates a videoSource. +func (db *VideoSourceDB) UpdateVideoSource(videoSourceID, description string) (*VideoSource, error) { + videoSource := VideoSource{} + err := db.SQL.Get(&videoSource, `UPDATE video_source SET description = $2 WHERE id = $1 RETURNING *`, videoSourceID, description) + return &videoSource, err +} + +// GetAllVideoSources returns all video sources in the database. +func (db *VideoSourceDB) GetAllVideoSources(includeTracks bool) ([]VideoSource, error) { + sources := make([]VideoSource, 0) + err := db.SQL.Select(&sources, baseVideoSourceQuery) + if includeTracks { + newSources := make([]VideoSource, 0) + for _, source := range sources { + allTracks, tracksErr := db.Collection.VideoSourceTrack.GetTracksForVideoSource(source.ID) + if tracksErr != nil { + return nil, tracksErr + } + source.Tracks = append(source.Tracks, allTracks...) + newSources = append(newSources, source) + } + return newSources, nil + } + return sources, err +} diff --git a/models/video_source_track.go b/models/video_source_track.go new file mode 100644 index 0000000..e011dcf --- /dev/null +++ b/models/video_source_track.go @@ -0,0 +1,107 @@ +package models + +import ( + "encoding/json" + "fmt" + "time" + + "github.com/jmoiron/sqlx" +) + +// VideoSourceTrackDB is a struct containing initialized the SQL connection as well as the APICollection. +type VideoSourceTrackDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newVideoSourceTrackDB( + SQL *sqlx.DB, + Collection *APICollection, +) *VideoSourceTrackDB { + db := &VideoSourceTrackDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *VideoSourceTrackDB) tableName() string { + return "video_source_track" +} + +type VideoSourceTrack struct { + ID int `db:"id"` + VideoSourceID int `db:"video_source_id"` + Name string `db:"name"` + Tags json.RawMessage `db:"tags"` + RawLine string `db:"raw_line"` + StreamURL string `db:"stream_url"` + HighDefinition bool `db:"hd"` + ImportedAt *time.Time `db:"imported_at"` +} + +// VideoSourceTrackAPI contains all methods for the User struct +type VideoSourceTrackAPI interface { + InsertVideoSourceTrack(trackStruct VideoSourceTrack) (*VideoSourceTrack, error) + DeleteVideoSourceTrack(trackID string) (*VideoSourceTrack, error) + UpdateVideoSourceTrack(trackID, description string) (*VideoSourceTrack, error) + GetVideoSourceTrackByID(id string) (*VideoSourceTrack, error) + GetTracksForVideoSource(videoSourceID int) ([]VideoSourceTrack, error) +} + +const baseVideoSourceTrackQuery string = ` +SELECT + T.id, + T.video_source_id, + T.name, + T.tags, + T.raw_line, + T.stream_url, + T.hd, + T.imported_at + FROM video_source_track T` + +// InsertVideoSourceTrack inserts a new VideoSourceTrack into the database. +func (db *VideoSourceTrackDB) InsertVideoSourceTrack(trackStruct VideoSourceTrack) (*VideoSourceTrack, error) { + track := VideoSourceTrack{} + res, err := db.SQL.NamedExec(` + INSERT INTO video_source_track (video_source_id, name, tags, raw_line, stream_url, hd) + VALUES (:video_source_id, :name, :tags, :raw_line, :stream_url, :hd);`, trackStruct) + if err != nil { + return &track, err + } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return &track, rowIDErr + } + err = db.SQL.Get(&track, "SELECT * FROM video_source_track WHERE id = $1", rowID) + return &track, err +} + +// GetVideoSourceTrackByID returns a single VideoSourceTrack for the given ID. +func (db *VideoSourceTrackDB) GetVideoSourceTrackByID(id string) (*VideoSourceTrack, error) { + var track VideoSourceTrack + err := db.SQL.Get(&track, fmt.Sprintf(`%s WHERE T.id = $1`, baseVideoSourceTrackQuery), id) + return &track, err +} + +// DeleteVideoSourceTrack marks a track with the given ID as deleted. +func (db *VideoSourceTrackDB) DeleteVideoSourceTrack(trackID string) (*VideoSourceTrack, error) { + track := VideoSourceTrack{} + err := db.SQL.Get(&track, `DELETE FROM video_source_track WHERE id = $1`, trackID) + return &track, err +} + +// UpdateVideoSourceTrack updates a track. +func (db *VideoSourceTrackDB) UpdateVideoSourceTrack(trackID, description string) (*VideoSourceTrack, error) { + track := VideoSourceTrack{} + err := db.SQL.Get(&track, `UPDATE video_source_track SET description = $2 WHERE id = $1 RETURNING *`, trackID, description) + return &track, err +} + +// GetTracksForVideoSource returns a slice of VideoSourceTracks for the given video source ID. +func (db *VideoSourceTrackDB) GetTracksForVideoSource(videoSourceID int) ([]VideoSourceTrack, error) { + tracks := make([]VideoSourceTrack, 0) + err := db.SQL.Select(&tracks, fmt.Sprintf(`%s WHERE T.video_source_id = $1`, baseVideoSourceTrackQuery), videoSourceID) + return tracks, err +} diff --git a/structs.go b/structs.go deleted file mode 100644 index c3977a3..0000000 --- a/structs.go +++ /dev/null @@ -1,121 +0,0 @@ -package main - -import ( - "encoding/json" - "encoding/xml" - "fmt" -) - -// DiscoveryData contains data about telly to expose in the HDHomeRun format for Plex detection. -type DiscoveryData struct { - FriendlyName string - Manufacturer string - ModelNumber string - FirmwareName string - TunerCount int - FirmwareVersion string - DeviceID string - DeviceAuth string - BaseURL string - LineupURL string -} - -// UPNP returns the UPNP representation of the DiscoveryData. -func (d *DiscoveryData) UPNP() UPNP { - return UPNP{ - SpecVersion: upnpVersion{ - Major: 1, Minor: 0, - }, - URLBase: d.BaseURL, - Device: upnpDevice{ - DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", - FriendlyName: d.FriendlyName, - Manufacturer: d.Manufacturer, - ModelName: d.ModelNumber, - ModelNumber: d.ModelNumber, - UDN: fmt.Sprintf("uuid:%s", d.DeviceID), - }, - } -} - -// LineupStatus exposes the status of the channel lineup. -type LineupStatus struct { - ScanInProgress convertibleBoolean - ScanPossible convertibleBoolean `json:",omitempty"` - Source string `json:",omitempty"` - SourceList []string `json:",omitempty"` - Progress int `json:",omitempty"` // Percent complete - Found int `json:",omitempty"` // Number of found channels -} - -type upnpVersion struct { - Major int32 `xml:"major"` - Minor int32 `xml:"minor"` -} - -type upnpDevice struct { - DeviceType string `xml:"deviceType"` - FriendlyName string `xml:"friendlyName"` - Manufacturer string `xml:"manufacturer"` - ModelName string `xml:"modelName"` - ModelNumber string `xml:"modelNumber"` - SerialNumber string `xml:"serialNumber"` - UDN string `xml:"UDN"` -} - -// UPNP describes the UPNP/SSDP XML. -type UPNP struct { - XMLName xml.Name `xml:"urn:schemas-upnp-org:device-1-0 root"` - SpecVersion upnpVersion `xml:"specVersion"` - URLBase string `xml:"URLBase"` - Device upnpDevice `xml:"device"` -} - -type convertibleBoolean bool - -func (bit *convertibleBoolean) MarshalJSON() ([]byte, error) { - var bitSetVar int8 - if *bit { - bitSetVar = 1 - } - - return json.Marshal(bitSetVar) -} - -func (bit *convertibleBoolean) UnmarshalJSON(data []byte) error { - asString := string(data) - if asString == "1" || asString == "true" { - *bit = true - } else if asString == "0" || asString == "false" { - *bit = false - } else { - return fmt.Errorf("Boolean unmarshal error: invalid input %s", asString) - } - return nil -} - -// MarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 -func (bit *convertibleBoolean) MarshalXML(e *xml.Encoder, start xml.StartElement) error { - var bitSetVar int8 - if *bit { - bitSetVar = 1 - } - - return e.EncodeElement(bitSetVar, start) -} - -// UnmarshalXML used to determine if the element is present or not. see https://stackoverflow.com/a/46516243 -func (bit *convertibleBoolean) UnmarshalXML(d *xml.Decoder, start xml.StartElement) error { - var asString string - if decodeErr := d.DecodeElement(&asString, &start); decodeErr != nil { - return decodeErr - } - if asString == "1" || asString == "true" { - *bit = true - } else if asString == "0" || asString == "false" { - *bit = false - } else { - return fmt.Errorf("Boolean unmarshal error: invalid input %s", asString) - } - return nil -} diff --git a/utils.go b/utils.go index 2bddd71..4110c54 100644 --- a/utils.go +++ b/utils.go @@ -3,7 +3,6 @@ package main import ( "fmt" "net" - "strconv" "github.com/spf13/viper" ) @@ -15,18 +14,3 @@ func getTCPAddr(key string) *net.TCPAddr { } return addr } - -func getDiscoveryData() DiscoveryData { - return DiscoveryData{ - FriendlyName: viper.GetString("discovery.device-friendly-name"), - Manufacturer: viper.GetString("discovery.device-manufacturer"), - ModelNumber: viper.GetString("discovery.device-model-number"), - FirmwareName: viper.GetString("discovery.device-firmware-name"), - TunerCount: viper.GetInt("iptv.streams"), - FirmwareVersion: viper.GetString("discovery.device-firmware-version"), - DeviceID: strconv.Itoa(viper.GetInt("discovery.device-id")), - DeviceAuth: viper.GetString("discovery.device-auth"), - BaseURL: fmt.Sprintf("http://%s", viper.GetString("web.base-address")), - LineupURL: fmt.Sprintf("http://%s/lineup.json", viper.GetString("web.base-address")), - } -} diff --git a/utils/main.go b/utils/main.go new file mode 100644 index 0000000..d448491 --- /dev/null +++ b/utils/main.go @@ -0,0 +1,16 @@ +package utils + +import ( + "fmt" + "net" + + "github.com/spf13/viper" +) + +func getTCPAddr(key string) *net.TCPAddr { + addr, addrErr := net.ResolveTCPAddr("tcp", viper.GetString(key)) + if addrErr != nil { + panic(fmt.Errorf("error parsing address %s: %s", viper.GetString(key), addrErr)) + } + return addr +} From ae0510cfe656c737169631405ae325c4c6db1d7b Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 23 Aug 2018 00:57:00 -0700 Subject: [PATCH 048/182] Checkpoint on API, too much to mention --- Gopkg.lock | 15 +++ api/guide.go | 62 ---------- api/guide_source.go | 54 +++++++++ api/lineup.go | 47 ++++++++ api/lineup_channel.go | 25 ++++ api/main.go | 24 ++-- api/tuner.go | 236 ++++++++++++++++++-------------------- api/utils.go | 102 +++++----------- api/xmltv.go | 46 ++++++++ context/context.go | 5 + main.go | 11 +- migrations/00001_init.sql | 29 ++++- models/lineup.go | 141 ++++++++++++++++++++--- models/lineup_channel.go | 101 ++++++++++++---- models/old_lineup.go | 6 +- models/video_source.go | 7 +- 16 files changed, 590 insertions(+), 321 deletions(-) delete mode 100644 api/guide.go create mode 100644 api/lineup.go create mode 100644 api/lineup_channel.go create mode 100644 api/xmltv.go diff --git a/Gopkg.lock b/Gopkg.lock index e1a0c8c..5407795 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -1,6 +1,20 @@ # This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. +[[projects]] + branch = "master" + digest = "1:2c68a4843f0c805c1f69225bee2c8effb7be91437aa427a0155383e9d551f486" + name = "github.com/NebulousLabs/go-upnp" + packages = [ + "goupnp", + "goupnp/httpu", + "goupnp/scpd", + "goupnp/soap", + "goupnp/ssdp", + ] + pruneopts = "UT" + revision = "29b680b06c82d044ebea91bf3069038eb562df2a" + [[projects]] branch = "master" digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d" @@ -372,6 +386,7 @@ analyzer-name = "dep" analyzer-version = 1 input-imports = [ + "github.com/NebulousLabs/go-upnp/goupnp", "github.com/gin-contrib/cors", "github.com/gin-gonic/gin", "github.com/gobuffalo/packr", diff --git a/api/guide.go b/api/guide.go deleted file mode 100644 index 5fb8277..0000000 --- a/api/guide.go +++ /dev/null @@ -1,62 +0,0 @@ -package api - -import ( - "encoding/json" - "net/http" - "strconv" - - "github.com/gin-gonic/gin" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" -) - -func addGuide(cc *context.CContext, c *gin.Context) { - var payload models.GuideSource - if c.BindJSON(&payload) == nil { - newProvider, providerErr := cc.API.GuideSource.InsertGuideSource(payload) - if providerErr != nil { - c.AbortWithError(http.StatusInternalServerError, providerErr) - return - } - - providerCfg := newProvider.ProviderConfiguration() - - log.Infof("providerCfg %+v", providerCfg) - - provider, providerErr := providerCfg.GetProvider() - if providerErr != nil { - c.AbortWithError(http.StatusInternalServerError, providerErr) - return - } - - log.Infoln("Detected passed config is for provider", provider.Name()) - - xmlTV, xmlErr := models.GetXMLTV(provider.EPGURL(), false) - if xmlErr != nil { - log.WithError(xmlErr).Errorln("unable to get XMLTV file") - c.AbortWithError(http.StatusBadRequest, xmlErr) - return - } - - for _, channel := range xmlTV.Channels { - displayNames, _ := json.Marshal(channel.DisplayNames) - urls, _ := json.Marshal(channel.URLs) - icons, _ := json.Marshal(channel.Icons) - newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(models.GuideSourceChannel{ - GuideID: newProvider.ID, - XMLTVID: channel.ID, - DisplayNames: displayNames, - URLs: urls, - Icons: icons, - ChannelNumber: strconv.Itoa(channel.LCN), - }) - if newChannelErr != nil { - log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") - c.AbortWithError(http.StatusInternalServerError, newChannelErr) - return - } - newProvider.Channels = append(newProvider.Channels, *newChannel) - } - c.JSON(http.StatusOK, newProvider) - } -} diff --git a/api/guide_source.go b/api/guide_source.go index 2f2b041..c94e178 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -1,12 +1,66 @@ package api import ( + "encoding/json" "net/http" + "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/models" ) +func addGuide(cc *context.CContext, c *gin.Context) { + var payload models.GuideSource + if c.BindJSON(&payload) == nil { + newProvider, providerErr := cc.API.GuideSource.InsertGuideSource(payload) + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + providerCfg := newProvider.ProviderConfiguration() + + log.Infof("providerCfg %+v", providerCfg) + + provider, providerErr := providerCfg.GetProvider() + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + log.Infoln("Detected passed config is for provider", provider.Name()) + + xmlTV, xmlErr := models.GetXMLTV(provider.EPGURL(), false) + if xmlErr != nil { + log.WithError(xmlErr).Errorln("unable to get XMLTV file") + c.AbortWithError(http.StatusBadRequest, xmlErr) + return + } + + for _, channel := range xmlTV.Channels { + displayNames, _ := json.Marshal(channel.DisplayNames) + urls, _ := json.Marshal(channel.URLs) + icons, _ := json.Marshal(channel.Icons) + newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(models.GuideSourceChannel{ + GuideID: newProvider.ID, + XMLTVID: channel.ID, + DisplayNames: displayNames, + URLs: urls, + Icons: icons, + ChannelNumber: strconv.Itoa(channel.LCN), + }) + if newChannelErr != nil { + log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") + c.AbortWithError(http.StatusInternalServerError, newChannelErr) + return + } + newProvider.Channels = append(newProvider.Channels, *newChannel) + } + c.JSON(http.StatusOK, newProvider) + } +} + func getGuideSources(cc *context.CContext, c *gin.Context) { sources, sourcesErr := cc.API.GuideSource.GetAllGuideSources(true) if sourcesErr != nil { diff --git a/api/lineup.go b/api/lineup.go new file mode 100644 index 0000000..131516f --- /dev/null +++ b/api/lineup.go @@ -0,0 +1,47 @@ +package api + +import ( + "net/http" + + "github.com/gin-gonic/gin" + "github.com/tellytv/telly/context" + "github.com/tellytv/telly/models" +) + +func addLineup(cc *context.CContext, c *gin.Context) { + var payload models.SQLLineup + if c.BindJSON(&payload) == nil { + newLineup, lineupErr := cc.API.Lineup.InsertLineup(payload) + if lineupErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupErr) + return + } + + tunerChan := make(chan bool) + cc.Tuners[newLineup.ID] = tunerChan + go ServeLineup(cc, tunerChan, newLineup) + + c.JSON(http.StatusOK, newLineup) + } +} + +func getLineups(cc *context.CContext, c *gin.Context) { + allLineups, lineupErr := cc.API.Lineup.GetEnabledLineups(true) + if lineupErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupErr) + return + } + + c.JSON(http.StatusOK, allLineups) +} + +func lineupRoute(cc *context.CContext, originalFunc func(*models.SQLLineup, *context.CContext, *gin.Context)) gin.HandlerFunc { + return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { + lineup, lineupErr := cc.API.Lineup.GetLineupByID(c.Param("lineupId")) + if lineupErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupErr) + return + } + originalFunc(lineup, cc, c) + }) +} diff --git a/api/lineup_channel.go b/api/lineup_channel.go new file mode 100644 index 0000000..2b747f0 --- /dev/null +++ b/api/lineup_channel.go @@ -0,0 +1,25 @@ +package api + +import ( + "net/http" + + "github.com/gin-gonic/gin" + "github.com/tellytv/telly/context" + "github.com/tellytv/telly/models" +) + +func addLineupChannel(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { + var payload models.LineupChannel + if c.BindJSON(&payload) == nil { + payload.LineupID = lineup.ID + newChannel, lineupErr := cc.API.LineupChannel.InsertLineupChannel(payload) + if lineupErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupErr) + return + } + + RestartTuner(cc, lineup) + + c.JSON(http.StatusOK, newChannel) + } +} diff --git a/api/main.go b/api/main.go index 4febd82..acf8bd3 100644 --- a/api/main.go +++ b/api/main.go @@ -4,13 +4,12 @@ import ( "bytes" "os" - "github.com/gin-contrib/cors" "github.com/gin-gonic/gin" "github.com/gobuffalo/packr" "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/context" - "github.com/zsais/go-gin-prometheus" + ginprometheus "github.com/zsais/go-gin-prometheus" ) var log = &logrus.Logger{ @@ -22,6 +21,8 @@ var log = &logrus.Logger{ Level: logrus.DebugLevel, } +var prom = ginprometheus.NewPrometheus("http") + func ServeAPI(cc *context.CContext) { log.Debugln("creating webserver routes") @@ -29,26 +30,23 @@ func ServeAPI(cc *context.CContext) { gin.SetMode(gin.ReleaseMode) } - router := gin.New() - router.Use(cors.Default()) - router.Use(gin.Recovery()) - - if viper.GetBool("log.logrequests") { - router.Use(ginrus()) - } - - p := ginprometheus.NewPrometheus("http") - p.Use(router) + router := newGin() box := packr.NewBox("../frontend/dist/telly-fe") router.Use(ServeBox("/", box)) + router.GET("/epg.xml", wrapContext(cc, xmlTV)) + apiGroup := router.Group("/api") - apiGroup.GET("/lineup/scan", scanM3U) apiGroup.GET("/guide/scan", scanXMLTV) + apiGroup.GET("/lineups", wrapContext(cc, getLineups)) + apiGroup.POST("/lineups", wrapContext(cc, addLineup)) + apiGroup.POST("/lineups/:lineupId/channels", lineupRoute(cc, addLineupChannel)) + apiGroup.GET("/lineup/scan", scanM3U) + apiGroup.GET("/guide_sources", wrapContext(cc, getGuideSources)) apiGroup.POST("/guide_sources", wrapContext(cc, addGuide)) diff --git a/api/tuner.go b/api/tuner.go index b6c1c10..f4f5a17 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -2,64 +2,72 @@ package api import ( "bufio" + "context" "encoding/xml" "fmt" "io" "net/http" "os/exec" - "sort" - "strconv" "strings" "time" - "github.com/gin-contrib/cors" + upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/gin-gonic/gin" ssdp "github.com/koron/go-ssdp" "github.com/spf13/viper" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/internal/xmltv" + ccontext "github.com/tellytv/telly/context" "github.com/tellytv/telly/models" - "github.com/zsais/go-gin-prometheus" ) -func ServeLineup(cc *context.CContext) { - discoveryData := GetDiscoveryData() +func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup) { + discoveryData := lineup.GetDiscoveryData() log.Debugln("creating device xml") upnp := discoveryData.UPNP() - router := gin.New() - router.Use(cors.Default()) - router.Use(gin.Recovery()) - - if viper.GetBool("log.logrequests") { - router.Use(ginrus()) - } - - p := ginprometheus.NewPrometheus("http") - p.Use(router) + router := newGin() router.GET("/", deviceXML(upnp)) router.GET("/device.xml", deviceXML(upnp)) router.GET("/discover.json", discovery(discoveryData)) - router.GET("/lineup_status.json", lineupStatus(false)) // FIXME: replace bool with cc.Lineup.Scanning - router.POST("/lineup.post", scanChannels(cc)) - router.GET("/lineup.json", serveHDHRLineup(cc.Lineup)) - router.GET("/lineup.xml", serveHDHRLineup(cc.Lineup)) - router.GET("/auto/:channelID", stream(cc.Lineup)) - router.GET("/epg.xml", xmlTV(cc.Lineup)) - router.GET("/debug.json", func(c *gin.Context) { - c.JSON(http.StatusOK, cc.Lineup) - }) + router.GET("/lineup_status.json", lineupStatus(lineup)) // FIXME: replace bool with lineup.Scanning + router.POST("/lineup.post", scanChannels(lineup)) + router.GET("/lineup.json", serveHDHRLineup(cc, lineup)) + router.GET("/lineup.xml", serveHDHRLineup(cc, lineup)) + router.GET("/auto/:channelID", stream(cc, lineup)) + + baseAddr := fmt.Sprintf("%s:%d", lineup.ListenAddress, lineup.Port) if viper.GetBool("discovery.ssdp") { - if _, ssdpErr := setupSSDP(viper.GetString("web.base-address"), viper.GetString("discovery.device-friendly-name"), viper.GetString("discovery.device-uuid")); ssdpErr != nil { + if _, ssdpErr := setupSSDP(baseAddr, lineup.Name, lineup.DeviceUUID); ssdpErr != nil { log.WithError(ssdpErr).Errorln("telly cannot advertise over ssdp") } } - if err := router.Run(viper.GetString("web.listen-address")); err != nil { - log.WithError(err).Panicln("Error starting up web server") + log.Infof(`telly lineup "%s" is live at http://%s/`, lineup.Name, baseAddr) + + srv := &http.Server{ + Addr: baseAddr, + Handler: router, + } + + go func() { + if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed { + log.WithError(err).Panicln("Error starting up web server") + } + }() + + for { + select { + case <-exit: + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + if err := srv.Shutdown(ctx); err != nil { + log.WithError(err).Fatalln("error during tuner shutdown") + } + log.Warnln("Tuner restart commanded") + return + } } } @@ -93,13 +101,18 @@ func setupSSDP(baseAddress, deviceName, deviceUUID string) (*ssdp.Advertiser, er return adv, nil } -func deviceXML(deviceXML UPNP) gin.HandlerFunc { +type dXMLContainer struct { + upnp.RootDevice + XMLName xml.Name `xml:"urn:schemas-upnp-org:device-1-0 root"` +} + +func deviceXML(deviceXML upnp.RootDevice) gin.HandlerFunc { return func(c *gin.Context) { - c.XML(http.StatusOK, deviceXML) + c.XML(http.StatusOK, dXMLContainer{deviceXML, xml.Name{}}) } } -func discovery(data DiscoveryData) gin.HandlerFunc { +func discovery(data models.DiscoveryData) gin.HandlerFunc { return func(c *gin.Context) { c.JSON(http.StatusOK, data) } @@ -110,131 +123,109 @@ type hdhrLineupContainer struct { Programs []models.HDHomeRunLineupItem } -func serveHDHRLineup(lineup *models.Lineup) gin.HandlerFunc { +func serveHDHRLineup(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return func(c *gin.Context) { - channels := make([]models.HDHomeRunLineupItem, 0) - for _, channel := range lineup.Channels { - channels = append(channels, channel) + + channels, channelsErr := cc.API.LineupChannel.GetChannelsForLineup(lineup.ID, true) + if channelsErr != nil { + c.AbortWithError(http.StatusInternalServerError, channelsErr) + return } - sort.Slice(channels, func(i, j int) bool { - return channels[i].GuideNumber < channels[j].GuideNumber - }) + + hdhrItems := make([]models.HDHomeRunLineupItem, 0) + for _, channel := range channels { + hdhrItems = append(hdhrItems, *channel.HDHR) + } + if strings.HasSuffix(c.Request.URL.String(), ".xml") { - buf, marshallErr := xml.MarshalIndent(hdhrLineupContainer{Programs: channels}, "", "\t") + buf, marshallErr := xml.MarshalIndent(hdhrLineupContainer{Programs: hdhrItems}, "", "\t") if marshallErr != nil { c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling lineup to XML")) } c.Data(http.StatusOK, "application/xml", []byte(``+"\n"+string(buf))) return } - c.JSON(http.StatusOK, channels) + c.JSON(http.StatusOK, hdhrItems) } } -func xmlTV(lineup *models.Lineup) gin.HandlerFunc { +func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return func(c *gin.Context) { - // FIXME: Move this outside of the function stuff. - epg := &xmltv.TV{ - GeneratorInfoName: "telly", - GeneratorInfoURL: "https://github.com/tellytv/telly", - } + channelID := c.Param("channelID")[1:] - for _, channel := range lineup.Channels { - if channel.ProviderChannel.EPGChannel != nil { - epg.Channels = append(epg.Channels, *channel.ProviderChannel.EPGChannel) - epg.Programmes = append(epg.Programmes, channel.ProviderChannel.EPGProgrammes...) - } + channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(channelID) + if channelErr != nil { + c.AbortWithError(http.StatusInternalServerError, channelErr) + return } - sort.Slice(epg.Channels, func(i, j int) bool { - return epg.Channels[i].LCN < epg.Channels[j].LCN - }) + log.Infof("Serving channel number %s", channelID) - buf, marshallErr := xml.MarshalIndent(epg, "", "\t") - if marshallErr != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling EPG to XML")) - } - c.Data(http.StatusOK, "application/xml", []byte(xml.Header+``+"\n"+string(buf))) - } -} - -func stream(lineup *models.Lineup) gin.HandlerFunc { - return func(c *gin.Context) { - channelIDStr := c.Param("channelID")[1:] - channelID, channelIDErr := strconv.Atoi(channelIDStr) - if channelIDErr != nil { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("that (%s) doesn't appear to be a valid channel number", channelIDStr)) + if !viper.IsSet("iptv.ffmpeg") { + c.Redirect(http.StatusMovedPermanently, channel.VideoTrack.StreamURL) return } - if channel, ok := lineup.Channels[channelID]; ok { - log.Infof("Serving channel number %d", channelID) + log.Infoln("Transcoding stream with ffmpeg") - if !viper.IsSet("iptv.ffmpeg") { - c.Redirect(http.StatusMovedPermanently, channel.ProviderChannel.Track.URI) - return - } + run := exec.Command("ffmpeg", "-re", "-i", channel.VideoTrack.StreamURL, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") + ffmpegout, err := run.StdoutPipe() + if err != nil { + log.WithError(err).Errorln("StdoutPipe Error") + return + } - log.Infoln("Transcoding stream with ffmpeg") + stderr, stderrErr := run.StderrPipe() + if stderrErr != nil { + log.WithError(stderrErr).Errorln("Error creating ffmpeg stderr pipe") + } - run := exec.Command("ffmpeg", "-re", "-i", channel.ProviderChannel.Track.URI, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") - ffmpegout, err := run.StdoutPipe() - if err != nil { - log.WithError(err).Errorln("StdoutPipe Error") - return - } + if startErr := run.Start(); startErr != nil { + log.WithError(startErr).Errorln("Error starting ffmpeg") + return + } - stderr, stderrErr := run.StderrPipe() - if stderrErr != nil { - log.WithError(stderrErr).Errorln("Error creating ffmpeg stderr pipe") + go func() { + scanner := bufio.NewScanner(stderr) + scanner.Split(split) + for scanner.Scan() { + log.Println(scanner.Text()) } + }() - if startErr := run.Start(); startErr != nil { - log.WithError(startErr).Errorln("Error starting ffmpeg") - return - } + continueStream := true - go func() { - scanner := bufio.NewScanner(stderr) - scanner.Split(split) - for scanner.Scan() { - log.Println(scanner.Text()) + c.Stream(func(w io.Writer) bool { + defer func() { + log.Infoln("Stopped streaming", channelID) + if killErr := run.Process.Kill(); killErr != nil { + panic(killErr) } + continueStream = false + return }() + if _, copyErr := io.Copy(w, ffmpegout); copyErr != nil { + log.WithError(copyErr).Errorln("Error when copying data") + continueStream = false + return false + } + return continueStream + }) - continueStream := true - - c.Stream(func(w io.Writer) bool { - defer func() { - log.Infoln("Stopped streaming", channelID) - if killErr := run.Process.Kill(); killErr != nil { - panic(killErr) - } - continueStream = false - return - }() - if _, copyErr := io.Copy(w, ffmpegout); copyErr != nil { - log.WithError(copyErr).Errorln("Error when copying data") - continueStream = false - return false - } - return continueStream - }) - - return - } + return c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %d", channelID)) } } -func scanChannels(cc *context.CContext) gin.HandlerFunc { +func scanChannels(lineup *models.SQLLineup) gin.HandlerFunc { return func(c *gin.Context) { scanAction := c.Query("scan") if scanAction == "start" { - if refreshErr := cc.Lineup.Scan(); refreshErr != nil { - c.AbortWithError(http.StatusInternalServerError, refreshErr) - } + // FIXME: Actually implement a scan... + // if refreshErr := lineup.Scan(); refreshErr != nil { + // c.AbortWithError(http.StatusInternalServerError, refreshErr) + // } c.AbortWithStatus(http.StatusOK) return } else if scanAction == "abort" { @@ -245,7 +236,7 @@ func scanChannels(cc *context.CContext) gin.HandlerFunc { } } -func lineupStatus(scanning bool) gin.HandlerFunc { +func lineupStatus(lineup *models.SQLLineup) gin.HandlerFunc { return func(c *gin.Context) { payload := LineupStatus{ ScanInProgress: models.ConvertibleBoolean(false), @@ -253,7 +244,8 @@ func lineupStatus(scanning bool) gin.HandlerFunc { Source: "Cable", SourceList: []string{"Cable"}, } - if scanning { + // FIXME: Implement a scan param on SQLLineup. + if false { payload = LineupStatus{ ScanInProgress: models.ConvertibleBoolean(true), // Gotta fake out Plex. diff --git a/api/utils.go b/api/utils.go index 9651de4..7bd8a0e 100644 --- a/api/utils.go +++ b/api/utils.go @@ -1,12 +1,10 @@ package api import ( - "encoding/xml" - "fmt" "net/http" - "strconv" "time" + "github.com/gin-contrib/cors" "github.com/gin-gonic/gin" "github.com/gobuffalo/packr" "github.com/sirupsen/logrus" @@ -45,38 +43,6 @@ func scanXMLTV(c *gin.Context) { c.JSON(http.StatusOK, epg) } -// DiscoveryData contains data about telly to expose in the HDHomeRun format for Plex detection. -type DiscoveryData struct { - FriendlyName string - Manufacturer string - ModelNumber string - FirmwareName string - TunerCount int - FirmwareVersion string - DeviceID string - DeviceAuth string - BaseURL string - LineupURL string -} - -// UPNP returns the UPNP representation of the DiscoveryData. -func (d *DiscoveryData) UPNP() UPNP { - return UPNP{ - SpecVersion: upnpVersion{ - Major: 1, Minor: 0, - }, - URLBase: d.BaseURL, - Device: upnpDevice{ - DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", - FriendlyName: d.FriendlyName, - Manufacturer: d.Manufacturer, - ModelName: d.ModelNumber, - ModelNumber: d.ModelNumber, - UDN: fmt.Sprintf("uuid:%s", d.DeviceID), - }, - } -} - // LineupStatus exposes the status of the channel lineup. type LineupStatus struct { ScanInProgress models.ConvertibleBoolean @@ -87,44 +53,6 @@ type LineupStatus struct { Found int `json:",omitempty"` // Number of found channels } -type upnpVersion struct { - Major int32 `xml:"major"` - Minor int32 `xml:"minor"` -} - -type upnpDevice struct { - DeviceType string `xml:"deviceType"` - FriendlyName string `xml:"friendlyName"` - Manufacturer string `xml:"manufacturer"` - ModelName string `xml:"modelName"` - ModelNumber string `xml:"modelNumber"` - SerialNumber string `xml:"serialNumber"` - UDN string `xml:"UDN"` -} - -// UPNP describes the UPNP/SSDP XML. -type UPNP struct { - XMLName xml.Name `xml:"urn:schemas-upnp-org:device-1-0 root"` - SpecVersion upnpVersion `xml:"specVersion"` - URLBase string `xml:"URLBase"` - Device upnpDevice `xml:"device"` -} - -func GetDiscoveryData() DiscoveryData { - return DiscoveryData{ - FriendlyName: viper.GetString("discovery.device-friendly-name"), - Manufacturer: viper.GetString("discovery.device-manufacturer"), - ModelNumber: viper.GetString("discovery.device-model-number"), - FirmwareName: viper.GetString("discovery.device-firmware-name"), - TunerCount: viper.GetInt("iptv.streams"), - FirmwareVersion: viper.GetString("discovery.device-firmware-version"), - DeviceID: strconv.Itoa(viper.GetInt("discovery.device-id")), - DeviceAuth: viper.GetString("discovery.device-auth"), - BaseURL: fmt.Sprintf("http://%s", viper.GetString("web.base-address")), - LineupURL: fmt.Sprintf("http://%s/lineup.json", viper.GetString("web.base-address")), - } -} - func ginrus() gin.HandlerFunc { return func(c *gin.Context) { start := time.Now() @@ -177,3 +105,31 @@ func ServeBox(urlPrefix string, box packr.Box) gin.HandlerFunc { } } } + +func newGin() *gin.Engine { + router := gin.New() + router.Use(cors.Default()) + router.Use(gin.Recovery()) + + if viper.GetBool("log.logrequests") { + router.Use(ginrus()) + } + + prom.Use(router) + return router +} + +func StartTuner(cc *context.CContext, lineup *models.SQLLineup) { + tunerChan := make(chan bool) + cc.Tuners[lineup.ID] = tunerChan + go ServeLineup(cc, tunerChan, lineup) + return +} + +func RestartTuner(cc *context.CContext, lineup *models.SQLLineup) { + if tuner, ok := cc.Tuners[lineup.ID]; ok { + tuner <- true + } + StartTuner(cc, lineup) + return +} diff --git a/api/xmltv.go b/api/xmltv.go new file mode 100644 index 0000000..d4e393c --- /dev/null +++ b/api/xmltv.go @@ -0,0 +1,46 @@ +package api + +import ( + "encoding/xml" + "fmt" + "net/http" + "sort" + + "github.com/gin-gonic/gin" + "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/xmltv" +) + +func xmlTV(cc *context.CContext, c *gin.Context) { + // FIXME: Move this outside of the function stuff. + epg := &xmltv.TV{ + GeneratorInfoName: "telly", + GeneratorInfoURL: "https://github.com/tellytv/telly", + } + + // FIXME: Not actually a lineup... + // lineup := &models.SQLLineup{} + + // lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(true) + // if lineupsErr != nil { + // c.AbortWithError(http.StatusInternalServerError, lineupsErr) + // return + // } + + // for _, channel := range lineup.Channels { + // if channel.ProviderChannel.EPGChannel != nil { + // epg.Channels = append(epg.Channels, *channel.ProviderChannel.EPGChannel) + // epg.Programmes = append(epg.Programmes, channel.ProviderChannel.EPGProgrammes...) + // } + // } + + sort.Slice(epg.Channels, func(i, j int) bool { + return epg.Channels[i].LCN < epg.Channels[j].LCN + }) + + buf, marshallErr := xml.MarshalIndent(epg, "", "\t") + if marshallErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling EPG to XML")) + } + c.Data(http.StatusOK, "application/xml", []byte(xml.Header+``+"\n"+string(buf))) +} diff --git a/context/context.go b/context/context.go index 3af178f..ef4d8d1 100644 --- a/context/context.go +++ b/context/context.go @@ -17,6 +17,7 @@ type CContext struct { Ctx ctx.Context Lineup *models.Lineup Log *logrus.Logger + Tuners map[int]chan bool RawSQL *sqlx.DB } @@ -28,6 +29,7 @@ func (cc *CContext) Copy() *CContext { Ctx: cc.Ctx, Lineup: cc.Lineup, Log: cc.Log, + Tuners: cc.Tuners, RawSQL: cc.RawSQL, } } @@ -61,11 +63,14 @@ func NewCContext() (*CContext, error) { // log.WithError(scanErr).Panicln("Error scanning lineup!") // } + tuners := make(map[int]chan bool) + context := &CContext{ API: api, Ctx: theCtx, Log: log, // Lineup: lineup, + Tuners: tuners, RawSQL: sql, } diff --git a/main.go b/main.go index 710961a..c40021d 100644 --- a/main.go +++ b/main.go @@ -150,7 +150,16 @@ func main() { cc, err := context.NewCContext() if err != nil { - log.Fatalln("Couldn't create context", err) + log.WithError(err).Panicln("Couldn't create context") + } + + lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(false) + if lineupsErr != nil { + log.WithError(lineupsErr).Panicln("Error getting all enabled lineups") + } + + for _, lineup := range lineups { + api.StartTuner(cc, &lineup) } api.ServeAPI(cc) diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql index 7dda913..0dcf335 100644 --- a/migrations/00001_init.sql +++ b/migrations/00001_init.sql @@ -8,6 +8,7 @@ CREATE TABLE IF NOT EXISTS video_source ( username VARCHAR(64) NULL, password VARCHAR(64) NULL, m3u_url TEXT, + max_streams INTEGER, imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); @@ -49,20 +50,38 @@ CREATE TABLE IF NOT EXISTS guide_source_channel ( ); CREATE TABLE IF NOT EXISTS lineup ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + ssdp BOOLEAN DEFAULT TRUE, + listen_address TEXT DEFAULT '127.0.0.1', + discovery_address TEXT DEFAULT '127.0.0.1', + port INTEGER, + tuners INTEGER, + manufacturer TEXT DEFAULT 'Silicondust', + model_name TEXT DEFAULT 'HDHomeRun EXTEND', + model_number TEXT DEFAULT 'HDTC-2US', + firmware_name TEXT DEFAULT 'hdhomeruntc_atsc', + firmware_version TEXT DEFAULT '20150826', + device_id TEXT DEFAULT '12345678', + device_auth TEXT DEFAULT 'telly', + device_uuid TEXT DEFAULT '12345678-AE2A-4E54-BBC9-33AF7D5D6A92', + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE IF NOT EXISTS lineup_channel ( id INTEGER PRIMARY KEY AUTOINCREMENT, + lineup_id INTEGER, title TEXT, channel_number TEXT, video_track_id INTEGER, - guide_channel_id TEXT, + guide_channel_id INTEGER, hd BOOLEAN, favorite BOOLEAN, - created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + + FOREIGN KEY(lineup_id) REFERENCES lineup(id), + FOREIGN KEY(video_track_id) REFERENCES video_source_track(id), + FOREIGN KEY(guide_channel_id) REFERENCES guide_source_channel(id) ); diff --git a/models/lineup.go b/models/lineup.go index 662b7b5..85efe14 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -4,6 +4,7 @@ import ( "fmt" "time" + upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/jmoiron/sqlx" ) @@ -28,11 +29,82 @@ func (db *LineupDB) tableName() string { return "lineup" } +// DiscoveryData contains data about telly to expose in the HDHomeRun format for Plex detection. +type DiscoveryData struct { + FriendlyName string + Manufacturer string + ModelName string + ModelNumber string + FirmwareName string + TunerCount int + FirmwareVersion string + DeviceID string + DeviceAuth string + BaseURL string + LineupURL string + DeviceUUID string +} + +// UPNP returns the UPNP representation of the DiscoveryData. +func (d *DiscoveryData) UPNP() upnp.RootDevice { + return upnp.RootDevice{ + SpecVersion: upnp.SpecVersion{ + Major: 1, Minor: 0, + }, + URLBaseStr: d.BaseURL, + Device: upnp.Device{ + DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", + FriendlyName: d.FriendlyName, + Manufacturer: d.Manufacturer, + ModelName: d.ModelName, + ModelNumber: d.ModelNumber, + ModelDescription: fmt.Sprintf("%s %s", d.ModelNumber, d.ModelName), + SerialNumber: d.DeviceID, + UDN: d.DeviceUUID, + PresentationURL: upnp.URLField{ + Str: "/", + }, + }, + } +} + type SQLLineup struct { - ID int `db:"id"` - Name string `db:"name"` - ChannelsStr string `db:"channels"` - CreatedAt *time.Time `db:"created_at"` + ID int `db:"id" json:"id"` + Name string `db:"name" json:"name"` + SSDP bool `db:"ssdp" json:"ssdp"` + ListenAddress string `db:"listen_address" json:"listenAddress"` + DiscoveryAddress string `db:"discovery_address" json:"discoveryAddress"` + Port int `db:"port" json:"port"` + Tuners int `db:"tuners" json:"tuners"` + Manufacturer string `db:"manufacturer" json:"manufacturer"` + ModelName string `db:"model_name" json:"modelName"` + ModelNumber string `db:"model_number" json:"modelNumber"` + FirmwareName string `db:"firmware_name" json:"firmwareName"` + FirmwareVersion string `db:"firmware_version" json:"firmwareVersion"` + DeviceID string `db:"device_id" json:"deviceID"` + DeviceAuth string `db:"device_auth" json:"deviceAuth"` + DeviceUUID string `db:"device_uuid" json:"deviceUUID"` + CreatedAt *time.Time `db:"created_at" json:"createdAt"` + + Channels []LineupChannel `json:"channels"` +} + +func (s *SQLLineup) GetDiscoveryData() DiscoveryData { + baseAddr := fmt.Sprintf("http://%s:%d", s.DiscoveryAddress, s.Port) + return DiscoveryData{ + FriendlyName: s.Name, + Manufacturer: s.Manufacturer, + ModelName: s.ModelName, + ModelNumber: s.ModelNumber, + FirmwareName: s.FirmwareName, + TunerCount: s.Tuners, + FirmwareVersion: s.FirmwareVersion, + DeviceID: s.DeviceID, + DeviceAuth: s.DeviceAuth, + BaseURL: baseAddr, + LineupURL: fmt.Sprintf("%s/lineup.json", baseAddr), + DeviceUUID: s.DeviceUUID, + } } // LineupAPI contains all methods for the User struct @@ -41,33 +113,44 @@ type LineupAPI interface { DeleteLineup(lineupID string) (*SQLLineup, error) UpdateLineup(lineupID, description string) (*SQLLineup, error) GetLineupByID(id string) (*SQLLineup, error) + GetEnabledLineups(withChannels bool) ([]SQLLineup, error) } const baseLineupQuery string = ` SELECT L.id, L.name, - L.channels, + L.ssdp, + L.listen_address, + L.discovery_address, + L.port, + L.tuners, + L.manufacturer, + L.model_name, + L.model_number, + L.firmware_name, + L.firmware_version, + L.device_id, + L.device_auth, + L.device_uuid, L.created_at - FROM lineups L` + FROM lineup L` // InsertLineup inserts a new Lineup into the database. func (db *LineupDB) InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) { lineup := SQLLineup{} - rows, err := db.SQL.NamedQuery(` - INSERT INTO lineups (name, channels, created_at) - VALUES (name, :channels, :created_at) - RETURNING *`, lineupStruct) + res, err := db.SQL.NamedExec(` + INSERT INTO lineup (name, ssdp, listen_address, discovery_address, port, tuners, manufacturer, model_name, model_number, firmware_name, firmware_version, device_id, device_auth, device_uuid) + VALUES (:name, :ssdp, :listen_address, :discovery_address, :port, :tuners, :manufacturer, :model_name, :model_number, :firmware_name, :firmware_version, :device_id, :device_auth, :device_uuid)`, lineupStruct) if err != nil { return &lineup, err } - for rows.Next() { - err := rows.StructScan(&lineup) - if err != nil { - return &lineup, err - } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return &lineup, rowIDErr } - return &lineup, nil + err = db.SQL.Get(&lineup, "SELECT * FROM lineup WHERE id = $1", rowID) + return &lineup, err } // GetLineupByID returns a single Lineup for the given ID. @@ -80,13 +163,35 @@ func (db *LineupDB) GetLineupByID(id string) (*SQLLineup, error) { // DeleteLineup marks a lineup with the given ID as deleted. func (db *LineupDB) DeleteLineup(lineupID string) (*SQLLineup, error) { lineup := SQLLineup{} - err := db.SQL.Get(&lineup, `DELETE FROM lineups WHERE id = $1`, lineupID) + err := db.SQL.Get(&lineup, `DELETE FROM lineup WHERE id = $1`, lineupID) return &lineup, err } // UpdateLineup updates a lineup. func (db *LineupDB) UpdateLineup(lineupID, description string) (*SQLLineup, error) { lineup := SQLLineup{} - err := db.SQL.Get(&lineup, `UPDATE lineups SET description = $2 WHERE id = $1 RETURNING *`, lineupID, description) + err := db.SQL.Get(&lineup, `UPDATE lineup SET description = $2 WHERE id = $1 RETURNING *`, lineupID, description) return &lineup, err } + +// GetEnabledLineups returns all enabled lineups in the database. +func (db *LineupDB) GetEnabledLineups(withChannels bool) ([]SQLLineup, error) { + lineups := make([]SQLLineup, 0) + err := db.SQL.Select(&lineups, baseLineupQuery) + if withChannels { + // newLineups := make([]SQLLineup, len(lineups)) + for idx, lineup := range lineups { + channels, channelsErr := db.Collection.LineupChannel.GetChannelsForLineup(lineup.ID, true) + if channelsErr != nil { + return nil, channelsErr + } + // lineup.HDHRItems = make([]HDHomeRunLineupItem, 0) + // for _, channel := range channels { + // lineup.HDHRItems = append(lineup.HDHRItems, channel.HDHomeRunLineupItem()) + // } + lineup.Channels = channels + lineups[idx] = lineup + } + } + return lineups, err +} diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 092fd76..2733cee 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -2,6 +2,7 @@ package models import ( "fmt" + "strconv" "time" "github.com/jmoiron/sqlx" @@ -25,18 +26,52 @@ func newLineupChannelDB( } func (db *LineupChannelDB) tableName() string { - return "lineup_channels" + return "lineup_channel" } type LineupChannel struct { - ID int `db:"id"` - Title string `db:"title"` - ChannelNumber string `db:"channel_number"` - VideoTrackID string `db:"video_track_id"` - GuideChannelID string `db:"guide_channel_id"` - HighDefinition bool `db:"hd"` - Favorite bool `db:"favorite"` - CreatedAt *time.Time `db:"created_at"` + ID int `db:"id" json:"id"` + LineupID int `db:"lineup_id" json:"lineupID"` + Title string `db:"title" json:"title"` + ChannelNumber string `db:"channel_number" json:"channelNumber"` + VideoTrackID int `db:"video_track_id" json:"videoTrackID"` + GuideChannelID int `db:"guide_channel_id" json:"guideChannelID"` + HighDefinition bool `db:"hd" json:"hd"` + Favorite bool `db:"favorite" json:"favorite"` + CreatedAt *time.Time `db:"created_at" json:"createdAt"` + + VideoTrack *VideoSourceTrack `json:"videoSourceTrack"` + GuideChannel *GuideSourceChannel `json:"guideSourceChannel"` + HDHR *HDHomeRunLineupItem + + lineup *SQLLineup +} + +func (l *LineupChannel) Fill(api *APICollection) { + gChannel, gChannelErr := api.GuideSourceChannel.GetGuideSourceChannelByID(strconv.Itoa(l.GuideChannelID)) + if gChannelErr != nil { + log.WithError(gChannelErr).Panicln("error getting channel during LineupChannel fill") + return + } + l.GuideChannel = gChannel + vTrack, vTrackErr := api.VideoSourceTrack.GetVideoSourceTrackByID(strconv.Itoa(l.VideoTrackID)) + if vTrackErr != nil { + log.WithError(vTrackErr).Panicln("error getting track during LineupChannel fill") + return + } + l.VideoTrack = vTrack + l.HDHR = l.HDHomeRunLineupItem() +} + +func (l *LineupChannel) HDHomeRunLineupItem() *HDHomeRunLineupItem { + return &HDHomeRunLineupItem{ + DRM: ConvertibleBoolean(false), + GuideName: l.Title, + GuideNumber: l.ChannelNumber, + Favorite: ConvertibleBoolean(l.Favorite), + HD: ConvertibleBoolean(l.HighDefinition), + URL: fmt.Sprintf("http://%s:%d/auto/v%s", l.lineup.DiscoveryAddress, l.lineup.Port, l.ChannelNumber), + } } // LineupChannelAPI contains all methods for the User struct @@ -45,11 +80,13 @@ type LineupChannelAPI interface { DeleteLineupChannel(channelID string) (*LineupChannel, error) UpdateLineupChannel(channelID, description string) (*LineupChannel, error) GetLineupChannelByID(id string) (*LineupChannel, error) + GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) } const baseLineupChannelQuery string = ` SELECT C.id, + C.lineup_id, C.title, C.channel_number, C.video_track_id, @@ -57,25 +94,23 @@ SELECT C.favorite, C.hd, C.created_at - FROM lineup_channels C` + FROM lineup_channel C` // InsertLineupChannel inserts a new LineupChannel into the database. func (db *LineupChannelDB) InsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) { channel := LineupChannel{} - rows, err := db.SQL.NamedQuery(` - INSERT INTO lineup_channels (title, channel_number, video_track_id, guide_channel_id, favorite, hd) - VALUES (:title, :channel_number, :video_track_id, :guide_channel_id, :favorite, :hd) - RETURNING *`, channelStruct) + res, err := db.SQL.NamedExec(` + INSERT INTO lineup_channel (lineup_id, title, channel_number, video_track_id, guide_channel_id, favorite, hd) + VALUES (:lineup_id, :title, :channel_number, :video_track_id, :guide_channel_id, :favorite, :hd)`, channelStruct) if err != nil { return &channel, err } - for rows.Next() { - err := rows.StructScan(&channel) - if err != nil { - return &channel, err - } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return &channel, rowIDErr } - return &channel, nil + err = db.SQL.Get(&channel, "SELECT * FROM lineup_channel WHERE id = $1", rowID) + return &channel, err } // GetLineupChannelByID returns a single LineupChannel for the given ID. @@ -88,13 +123,35 @@ func (db *LineupChannelDB) GetLineupChannelByID(id string) (*LineupChannel, erro // DeleteLineupChannel marks a channel with the given ID as deleted. func (db *LineupChannelDB) DeleteLineupChannel(channelID string) (*LineupChannel, error) { channel := LineupChannel{} - err := db.SQL.Get(&channel, `DELETE FROM lineup_channels WHERE id = $1`, channelID) + err := db.SQL.Get(&channel, `DELETE FROM lineup_channel WHERE id = $1`, channelID) return &channel, err } // UpdateLineupChannel updates a channel. func (db *LineupChannelDB) UpdateLineupChannel(channelID, description string) (*LineupChannel, error) { channel := LineupChannel{} - err := db.SQL.Get(&channel, `UPDATE lineup_channels SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) + err := db.SQL.Get(&channel, `UPDATE lineup_channel SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) return &channel, err } + +// GetChannelsForLineup returns a slice of LineupChannels for the given lineup ID. +func (db *LineupChannelDB) GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) { + channels := make([]LineupChannel, 0) + err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE C.lineup_id = $1`, baseLineupChannelQuery), lineupID) + if err != nil { + return nil, err + } + if expanded { + // Need to get the address and port number to properly fill + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(strconv.Itoa(lineupID)) + if lineupErr != nil { + return nil, lineupErr + } + for idx, channel := range channels { + channel.lineup = lineup + channel.Fill(db.Collection) + channels[idx] = channel + } + } + return channels, nil +} diff --git a/models/old_lineup.go b/models/old_lineup.go index 8f389a8..602914f 100644 --- a/models/old_lineup.go +++ b/models/old_lineup.go @@ -33,20 +33,20 @@ type HDHomeRunLineupItem struct { DRM ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` Favorite ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` GuideName string `xml:",omitempty" json:",omitempty"` - GuideNumber int `xml:",omitempty" json:",string,omitempty"` + GuideNumber string `xml:",omitempty" json:",omitempty"` HD ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` URL string `xml:",omitempty" json:",omitempty"` VideoCodec string `xml:",omitempty" json:",omitempty"` provider providers.Provider - ProviderChannel providers.ProviderChannel + ProviderChannel providers.ProviderChannel `json:"-"` } func newHDHRItem(provider *providers.Provider, ProviderChannel *providers.ProviderChannel) HDHomeRunLineupItem { return HDHomeRunLineupItem{ DRM: ConvertibleBoolean(false), GuideName: ProviderChannel.Name, - GuideNumber: ProviderChannel.Number, + GuideNumber: strconv.Itoa(ProviderChannel.Number), Favorite: ConvertibleBoolean(ProviderChannel.Favorite), HD: ConvertibleBoolean(ProviderChannel.HD), URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), ProviderChannel.Number), diff --git a/models/video_source.go b/models/video_source.go index dc099cb..6282deb 100644 --- a/models/video_source.go +++ b/models/video_source.go @@ -36,6 +36,7 @@ type VideoSource struct { Username string `db:"username" json:"username,omitempty"` Password string `db:"password" json:"password,omitempty"` M3UURL string `db:"m3u_url" json:"m3uURL,omitempty"` + MaxStreams int `db:"max_streams" json:"maxStreams,omitempty"` ImportedAt *time.Time `db:"imported_at" json:"importedAt,omitempty"` Tracks []VideoSourceTrack `db:"tracks" json:"tracks,omitempty"` @@ -67,6 +68,8 @@ SELECT V.provider, V.username, V.password, + V.m3u_url, + V.max_streams, V.imported_at FROM video_source V` @@ -74,8 +77,8 @@ SELECT func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) { videoSource := VideoSource{} res, err := db.SQL.NamedExec(` - INSERT INTO video_source (name, provider, username, password, m3u_url) - VALUES (:name, :provider, :username, :password, :m3u_url);`, videoSourceStruct) + INSERT INTO video_source (name, provider, username, password, m3u_url, max_streams) + VALUES (:name, :provider, :username, :password, :m3u_url, :max_streams);`, videoSourceStruct) if err != nil { return &videoSource, err } From afbbc56813809267e335c9b2a1a1faacaa6bd17f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 23 Aug 2018 01:01:38 -0700 Subject: [PATCH 049/182] Fix GetLineupChannelByID issues --- models/lineup_channel.go | 15 ++++++++++++++- 1 file changed, 14 insertions(+), 1 deletion(-) diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 2733cee..4eadddd 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -116,7 +116,20 @@ func (db *LineupChannelDB) InsertLineupChannel(channelStruct LineupChannel) (*Li // GetLineupChannelByID returns a single LineupChannel for the given ID. func (db *LineupChannelDB) GetLineupChannelByID(id string) (*LineupChannel, error) { var channel LineupChannel - err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE G.id = $1`, baseLineupChannelQuery), id) + err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE C.id = $1`, baseLineupChannelQuery), id) + if err != nil { + return nil, err + } + + // Need to get the address and port number to properly fill + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(strconv.Itoa(channel.LineupID)) + if lineupErr != nil { + return nil, lineupErr + } + + channel.lineup = lineup + channel.Fill(db.Collection) + return &channel, err } From 9965fdcc85bc71f5d498a7990f22e6b38213e306 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 23 Aug 2018 01:46:13 -0700 Subject: [PATCH 050/182] Add ffmpeg status parser --- api/main.go | 20 ------------ api/tuner.go | 89 ++++++++++++++++++++++++++++++++++++++++++++++++++-- 2 files changed, 87 insertions(+), 22 deletions(-) diff --git a/api/main.go b/api/main.go index acf8bd3..6880b9b 100644 --- a/api/main.go +++ b/api/main.go @@ -1,7 +1,6 @@ package api import ( - "bytes" "os" "github.com/gin-gonic/gin" @@ -61,22 +60,3 @@ func ServeAPI(cc *context.CContext) { log.WithError(err).Panicln("Error starting up web server") } } - -func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error) { - if atEOF && len(data) == 0 { - return 0, nil, nil - } - if i := bytes.IndexByte(data, '\n'); i >= 0 { - // We have a full newline-terminated line. - return i + 1, data[0:i], nil - } - if i := bytes.IndexByte(data, '\r'); i >= 0 { - // We have a cr terminated line - return i + 1, data[0:i], nil - } - if atEOF { - return len(data), data, nil - } - - return 0, nil, nil -} diff --git a/api/tuner.go b/api/tuner.go index f4f5a17..7af6358 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -2,12 +2,14 @@ package api import ( "bufio" + "bytes" "context" "encoding/xml" "fmt" "io" "net/http" "os/exec" + "regexp" "strings" "time" @@ -168,7 +170,7 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { log.Infoln("Transcoding stream with ffmpeg") - run := exec.Command("ffmpeg", "-re", "-i", channel.VideoTrack.StreamURL, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") + run := exec.Command("ffmpeg", "-re", "-i", channel.VideoTrack.StreamURL, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "-progress", "pipe:2", "pipe:1") ffmpegout, err := run.StdoutPipe() if err != nil { log.WithError(err).Errorln("StdoutPipe Error") @@ -188,8 +190,15 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { go func() { scanner := bufio.NewScanner(stderr) scanner.Split(split) + buf := make([]byte, 2) + scanner.Buffer(buf, bufio.MaxScanTokenSize) + for scanner.Scan() { - log.Println(scanner.Text()) + line := scanner.Text() + status := processFFMPEGStatus(line) + if status != nil { + fmt.Printf("\rFFMPEG Status: channel number: %d bitrate: %s frames: %s total time: %s speed: %s", channel.ID, status.CurrentBitrate, status.FramesProcessed, status.CurrentTime, status.Speed) + } } }() @@ -257,3 +266,79 @@ func lineupStatus(lineup *models.SQLLineup) gin.HandlerFunc { c.JSON(http.StatusOK, payload) } } + +func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error) { + if atEOF && len(data) == 0 { + return 0, nil, nil + } + if i := bytes.IndexByte(data, '\n'); i >= 0 { + // We have a full newline-terminated line. + return i + 1, data[0:i], nil + } + if i := bytes.IndexByte(data, '\r'); i >= 0 { + // We have a cr terminated line + return i + 1, data[0:i], nil + } + if atEOF { + return len(data), data, nil + } + + return 0, nil, nil +} + +type FFMPEGStatus struct { + FramesProcessed string + CurrentTime string + CurrentBitrate string + Progress float64 + Speed string +} + +func processFFMPEGStatus(line string) *FFMPEGStatus { + status := new(FFMPEGStatus) + if strings.Contains(line, "frame=") && strings.Contains(line, "time=") && strings.Contains(line, "bitrate=") { + var re = regexp.MustCompile(`=\s+`) + st := re.ReplaceAllString(line, `=`) + + f := strings.Fields(st) + var framesProcessed string + var currentTime string + var currentBitrate string + var currentSpeed string + + for j := 0; j < len(f); j++ { + field := f[j] + fieldSplit := strings.Split(field, "=") + + if len(fieldSplit) > 1 { + fieldname := strings.Split(field, "=")[0] + fieldvalue := strings.Split(field, "=")[1] + + if fieldname == "frame" { + framesProcessed = fieldvalue + } + + if fieldname == "time" { + currentTime = fieldvalue + } + + if fieldname == "bitrate" { + currentBitrate = fieldvalue + } + if fieldname == "speed" { + currentSpeed = fieldvalue + if currentSpeed == "1x" { + currentSpeed = "1.000x" + } + } + } + } + + status.CurrentBitrate = currentBitrate + status.FramesProcessed = framesProcessed + status.CurrentTime = currentTime + status.Speed = currentSpeed + return status + } + return nil +} From b4f8233ae873612b7f29846d25df1364bf866e5f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 23 Aug 2018 15:21:10 -0700 Subject: [PATCH 051/182] Metrics improvements --- api/main.go | 20 +++++++++++--------- api/tuner.go | 36 ++++++++++++++++++++---------------- main.go | 10 ---------- metrics/metrics.go | 45 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 76 insertions(+), 35 deletions(-) create mode 100644 metrics/metrics.go diff --git a/api/main.go b/api/main.go index 6880b9b..9fb6819 100644 --- a/api/main.go +++ b/api/main.go @@ -11,16 +11,18 @@ import ( ginprometheus "github.com/zsais/go-gin-prometheus" ) -var log = &logrus.Logger{ - Out: os.Stderr, - Formatter: &logrus.TextFormatter{ - FullTimestamp: true, - }, - Hooks: make(logrus.LevelHooks), - Level: logrus.DebugLevel, -} +var ( + log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } -var prom = ginprometheus.NewPrometheus("http") + prom = ginprometheus.NewPrometheus("http") +) func ServeAPI(cc *context.CContext) { log.Debugln("creating webserver routes") diff --git a/api/tuner.go b/api/tuner.go index 7af6358..b7e768b 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -18,10 +18,23 @@ import ( ssdp "github.com/koron/go-ssdp" "github.com/spf13/viper" ccontext "github.com/tellytv/telly/context" + "github.com/tellytv/telly/metrics" "github.com/tellytv/telly/models" ) func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup) { + channels, channelsErr := cc.API.LineupChannel.GetChannelsForLineup(lineup.ID, true) + if channelsErr != nil { + log.WithError(channelsErr).Errorln("error getting channels in lineup") + return + } + + hdhrItems := make([]models.HDHomeRunLineupItem, 0) + for _, channel := range channels { + hdhrItems = append(hdhrItems, *channel.HDHR) + } + + metrics.ExposedChannels.WithLabelValues(lineup.Name).Set(float64(len(channels))) discoveryData := lineup.GetDiscoveryData() log.Debugln("creating device xml") @@ -32,10 +45,10 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup router.GET("/", deviceXML(upnp)) router.GET("/device.xml", deviceXML(upnp)) router.GET("/discover.json", discovery(discoveryData)) - router.GET("/lineup_status.json", lineupStatus(lineup)) // FIXME: replace bool with lineup.Scanning + router.GET("/lineup_status.json", lineupStatus(lineup)) router.POST("/lineup.post", scanChannels(lineup)) - router.GET("/lineup.json", serveHDHRLineup(cc, lineup)) - router.GET("/lineup.xml", serveHDHRLineup(cc, lineup)) + router.GET("/lineup.json", serveHDHRLineup(hdhrItems)) + router.GET("/lineup.xml", serveHDHRLineup(hdhrItems)) router.GET("/auto/:channelID", stream(cc, lineup)) baseAddr := fmt.Sprintf("%s:%d", lineup.ListenAddress, lineup.Port) @@ -125,20 +138,8 @@ type hdhrLineupContainer struct { Programs []models.HDHomeRunLineupItem } -func serveHDHRLineup(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { +func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { return func(c *gin.Context) { - - channels, channelsErr := cc.API.LineupChannel.GetChannelsForLineup(lineup.ID, true) - if channelsErr != nil { - c.AbortWithError(http.StatusInternalServerError, channelsErr) - return - } - - hdhrItems := make([]models.HDHomeRunLineupItem, 0) - for _, channel := range channels { - hdhrItems = append(hdhrItems, *channel.HDHR) - } - if strings.HasSuffix(c.Request.URL.String(), ".xml") { buf, marshallErr := xml.MarshalIndent(hdhrLineupContainer{Programs: hdhrItems}, "", "\t") if marshallErr != nil { @@ -187,6 +188,8 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return } + metrics.ActiveStreams.WithLabelValues(lineup.Name).Inc() + go func() { scanner := bufio.NewScanner(stderr) scanner.Split(split) @@ -206,6 +209,7 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { c.Stream(func(w io.Writer) bool { defer func() { + metrics.ActiveStreams.WithLabelValues(lineup.Name).Dec() log.Infoln("Stopped streaming", channelID) if killErr := run.Process.Kill(); killErr != nil { panic(killErr) diff --git a/main.go b/main.go index c40021d..94fadde 100644 --- a/main.go +++ b/main.go @@ -8,7 +8,6 @@ import ( "os" "regexp" - "github.com/prometheus/client_golang/prometheus" "github.com/prometheus/common/version" "github.com/sirupsen/logrus" flag "github.com/spf13/pflag" @@ -28,13 +27,6 @@ var ( Hooks: make(logrus.LevelHooks), Level: logrus.DebugLevel, } - - exposedChannels = prometheus.NewGauge( - prometheus.GaugeOpts{ - Name: "exposed_channels_total", - Help: "Number of exposed channels.", - }, - ) ) func main() { @@ -124,8 +116,6 @@ func main() { } } - prometheus.MustRegister(version.NewCollector("telly"), exposedChannels) - level, parseLevelErr := logrus.ParseLevel(viper.GetString("log.level")) if parseLevelErr != nil { log.WithError(parseLevelErr).Panicln("error setting log level!") diff --git a/metrics/metrics.go b/metrics/metrics.go new file mode 100644 index 0000000..a1c529c --- /dev/null +++ b/metrics/metrics.go @@ -0,0 +1,45 @@ +//Package metrics provides Prometheus metrics. +package metrics + +import ( + "github.com/prometheus/client_golang/prometheus" + "github.com/prometheus/common/version" +) + +var ( + // ExposedChannels tracks the total number of exposed channels + ExposedChannels = prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Namespace: "telly", + Subsystem: "tuner", + Name: "channels_total", + Help: "Number of exposed channels.", + }, + []string{"lineup_name"}, + ) + ActiveStreams = prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Namespace: "telly", + Subsystem: "tuner", + Name: "active_total", + Help: "Number of active streams. Only activated if ffmpeg is enabled.", + }, + []string{"lineup_name"}, + ) + StreamTime = prometheus.NewGaugeVec( + prometheus.GaugeOpts{ + Namespace: "telly", + Subsystem: "tuner", + Name: "stream_time", + Help: "Amount of stream time in seconds.", + }, + []string{"lineup_name", "channel_name", "channel_number"}, + ) +) + +func init() { + version.NewCollector("telly") + prometheus.MustRegister(ExposedChannels) + prometheus.MustRegister(ActiveStreams) + prometheus.MustRegister(StreamTime) +} From 6070c71ff1534a4274dde3926a1dd249e6dfffe9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 23 Aug 2018 22:29:53 -0700 Subject: [PATCH 052/182] Changes to support frontend --- api/guide_source.go | 19 +++++++++++ api/lineup.go | 8 ++++- api/lineup_channel.go | 4 +++ api/main.go | 3 ++ api/tuner.go | 7 +++- api/video_source.go | 19 +++++++++++ models/guide_source.go | 28 ++++++++-------- models/guide_source_channel.go | 43 +++++++++++++++--------- models/lineup.go | 60 ++++++++++++++++++---------------- models/lineup_channel.go | 45 +++++++++++++------------ models/old_lineup.go | 1 + models/video_source.go | 30 ++++++++--------- models/video_source_track.go | 24 ++++++++++---- 13 files changed, 186 insertions(+), 105 deletions(-) diff --git a/api/guide_source.go b/api/guide_source.go index c94e178..1a7ff44 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -69,3 +69,22 @@ func getGuideSources(cc *context.CContext, c *gin.Context) { } c.JSON(http.StatusOK, sources) } + +func getAllChannels(cc *context.CContext, c *gin.Context) { + sources, sourcesErr := cc.API.GuideSource.GetAllGuideSources(true) + if sourcesErr != nil { + c.AbortWithError(http.StatusInternalServerError, sourcesErr) + return + } + + channels := make([]models.GuideSourceChannel, 0) + + for _, source := range sources { + for _, channel := range source.Channels { + channel.GuideSourceName = source.Name + channels = append(channels, channel) + } + } + + c.JSON(http.StatusOK, channels) +} diff --git a/api/lineup.go b/api/lineup.go index 131516f..7cf65db 100644 --- a/api/lineup.go +++ b/api/lineup.go @@ -2,6 +2,7 @@ package api import ( "net/http" + "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" @@ -37,7 +38,12 @@ func getLineups(cc *context.CContext, c *gin.Context) { func lineupRoute(cc *context.CContext, originalFunc func(*models.SQLLineup, *context.CContext, *gin.Context)) gin.HandlerFunc { return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { - lineup, lineupErr := cc.API.Lineup.GetLineupByID(c.Param("lineupId")) + lineupID, lineupIDErr := strconv.Atoi(c.Param("lineupId")) + if lineupIDErr != nil { + c.AbortWithError(http.StatusBadRequest, lineupIDErr) + return + } + lineup, lineupErr := cc.API.Lineup.GetLineupByID(lineupID, true) if lineupErr != nil { c.AbortWithError(http.StatusInternalServerError, lineupErr) return diff --git a/api/lineup_channel.go b/api/lineup_channel.go index 2b747f0..fa8e9df 100644 --- a/api/lineup_channel.go +++ b/api/lineup_channel.go @@ -8,6 +8,10 @@ import ( "github.com/tellytv/telly/models" ) +func getLineup(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { + c.JSON(http.StatusOK, lineup) +} + func addLineupChannel(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { var payload models.LineupChannel if c.BindJSON(&payload) == nil { diff --git a/api/main.go b/api/main.go index 9fb6819..f64793e 100644 --- a/api/main.go +++ b/api/main.go @@ -45,14 +45,17 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/lineups", wrapContext(cc, getLineups)) apiGroup.POST("/lineups", wrapContext(cc, addLineup)) + apiGroup.GET("/lineups/:lineupId", lineupRoute(cc, getLineup)) apiGroup.POST("/lineups/:lineupId/channels", lineupRoute(cc, addLineupChannel)) apiGroup.GET("/lineup/scan", scanM3U) apiGroup.GET("/guide_sources", wrapContext(cc, getGuideSources)) apiGroup.POST("/guide_sources", wrapContext(cc, addGuide)) + apiGroup.GET("/guide_sources/channels", wrapContext(cc, getAllChannels)) apiGroup.GET("/video_sources", wrapContext(cc, getVideoSources)) apiGroup.POST("/video_sources", wrapContext(cc, addVideoSource)) + apiGroup.GET("/video_sources/tracks", wrapContext(cc, getAllTracks)) log.Infof("telly is live and on the air!") log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) diff --git a/api/tuner.go b/api/tuner.go index b7e768b..f66d656 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -10,6 +10,7 @@ import ( "net/http" "os/exec" "regexp" + "strconv" "strings" "time" @@ -154,7 +155,11 @@ func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return func(c *gin.Context) { - channelID := c.Param("channelID")[1:] + channelID, channelIDErr := strconv.Atoi(c.Param("channelID")[1:]) + if channelIDErr != nil { + c.AbortWithError(http.StatusBadRequest, channelIDErr) + return + } channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(channelID) if channelErr != nil { diff --git a/api/video_source.go b/api/video_source.go index ec72d36..69e807c 100644 --- a/api/video_source.go +++ b/api/video_source.go @@ -73,3 +73,22 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { c.JSON(http.StatusOK, newProvider) } } + +func getAllTracks(cc *context.CContext, c *gin.Context) { + sources, sourcesErr := cc.API.VideoSource.GetAllVideoSources(true) + if sourcesErr != nil { + c.AbortWithError(http.StatusInternalServerError, sourcesErr) + return + } + + tracks := make([]models.VideoSourceTrack, 0) + + for _, source := range sources { + for _, track := range source.Tracks { + track.VideoSourceName = source.Name + tracks = append(tracks, track) + } + } + + c.JSON(http.StatusOK, tracks) +} diff --git a/models/guide_source.go b/models/guide_source.go index 449c760..e8b3b6d 100644 --- a/models/guide_source.go +++ b/models/guide_source.go @@ -30,15 +30,15 @@ func (db *GuideSourceDB) tableName() string { } type GuideSource struct { - ID int `db:"id" json:"id"` - Name string `db:"name" json:"name"` - Provider string `db:"provider" json:"provider"` - Username string `db:"username" json:"username"` - Password string `db:"password" json:"password"` - URL string `db:"xmltv_url" json:"url"` - ImportedAt *time.Time `db:"imported_at" json:"importedAt"` + ID int `db:"id"` + Name string `db:"name"` + Provider string `db:"provider"` + Username string `db:"username"` + Password string `db:"password"` + URL string `db:"xmltv_url"` + ImportedAt *time.Time `db:"imported_at"` - Channels []GuideSourceChannel `db:"-" json:"channels"` + Channels []GuideSourceChannel `db:"-"` } func (g *GuideSource) ProviderConfiguration() *providers.Configuration { @@ -54,9 +54,9 @@ func (g *GuideSource) ProviderConfiguration() *providers.Configuration { // GuideSourceAPI contains all methods for the User struct type GuideSourceAPI interface { InsertGuideSource(guideSourceStruct GuideSource) (*GuideSource, error) - DeleteGuideSource(guideSourceID string) (*GuideSource, error) - UpdateGuideSource(guideSourceID, description string) (*GuideSource, error) - GetGuideSourceByID(id string) (*GuideSource, error) + DeleteGuideSource(guideSourceID int) (*GuideSource, error) + UpdateGuideSource(guideSourceID int, description string) (*GuideSource, error) + GetGuideSourceByID(id int) (*GuideSource, error) GetAllGuideSources(includeChannels bool) ([]GuideSource, error) } @@ -89,21 +89,21 @@ func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource) (*Guid } // GetGuideSourceByID returns a single GuideSource for the given ID. -func (db *GuideSourceDB) GetGuideSourceByID(id string) (*GuideSource, error) { +func (db *GuideSourceDB) GetGuideSourceByID(id int) (*GuideSource, error) { var guideSource GuideSource err := db.SQL.Get(&guideSource, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceQuery), id) return &guideSource, err } // DeleteGuideSource marks a guideSource with the given ID as deleted. -func (db *GuideSourceDB) DeleteGuideSource(guideSourceID string) (*GuideSource, error) { +func (db *GuideSourceDB) DeleteGuideSource(guideSourceID int) (*GuideSource, error) { guideSource := GuideSource{} err := db.SQL.Get(&guideSource, `DELETE FROM guide_source WHERE id = $1`, guideSourceID) return &guideSource, err } // UpdateGuideSource updates a guideSource. -func (db *GuideSourceDB) UpdateGuideSource(guideSourceID, description string) (*GuideSource, error) { +func (db *GuideSourceDB) UpdateGuideSource(guideSourceID int, description string) (*GuideSource, error) { guideSource := GuideSource{} err := db.SQL.Get(&guideSource, `UPDATE guide_source SET description = $2 WHERE id = $1 RETURNING *`, guideSourceID, description) return &guideSource, err diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index d2a55a9..6bbe693 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -30,23 +30,26 @@ func (db *GuideSourceChannelDB) tableName() string { } type GuideSourceChannel struct { - ID int `db:"id" json:"id"` - GuideID int `db:"guide_id" json:"guideID"` - XMLTVID string `db:"xmltv_id" json:"xmltvID"` - DisplayNames json.RawMessage `db:"display_names" json:"displayNames"` - URLs json.RawMessage `db:"urls" json:"urls"` - Icons json.RawMessage `db:"icons" json:"icons"` - ChannelNumber string `db:"channel_number" json:"channelNumber"` - HighDefinition bool `db:"hd" json:"hd"` - ImportedAt *time.Time `db:"imported_at" json:"importedAt"` + ID int `db:"id"` + GuideID int `db:"guide_id"` + XMLTVID string `db:"xmltv_id"` + DisplayNames json.RawMessage `db:"display_names"` + URLs json.RawMessage `db:"urls"` + Icons json.RawMessage `db:"icons"` + ChannelNumber string `db:"channel_number"` + HighDefinition bool `db:"hd" json:"HD"` + ImportedAt *time.Time `db:"imported_at"` + + GuideSource *GuideSource + GuideSourceName string } // GuideSourceChannelAPI contains all methods for the User struct type GuideSourceChannelAPI interface { InsertGuideSourceChannel(channelStruct GuideSourceChannel) (*GuideSourceChannel, error) - DeleteGuideSourceChannel(channelID string) (*GuideSourceChannel, error) - UpdateGuideSourceChannel(channelID, description string) (*GuideSourceChannel, error) - GetGuideSourceChannelByID(id string) (*GuideSourceChannel, error) + DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) + UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) + GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) GetChannelsForGuideSource(guideSourceID int) ([]GuideSourceChannel, error) } @@ -81,21 +84,31 @@ func (db *GuideSourceChannelDB) InsertGuideSourceChannel(channelStruct GuideSour } // GetGuideSourceChannelByID returns a single GuideSourceChannel for the given ID. -func (db *GuideSourceChannelDB) GetGuideSourceChannelByID(id string) (*GuideSourceChannel, error) { +func (db *GuideSourceChannelDB) GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) { var channel GuideSourceChannel err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceChannelQuery), id) + if err != nil { + return nil, err + } + if expanded { + guide, guideErr := db.Collection.GuideSource.GetGuideSourceByID(channel.GuideID) + if guideErr != nil { + return nil, guideErr + } + channel.GuideSource = guide + } return &channel, err } // DeleteGuideSourceChannel marks a channel with the given ID as deleted. -func (db *GuideSourceChannelDB) DeleteGuideSourceChannel(channelID string) (*GuideSourceChannel, error) { +func (db *GuideSourceChannelDB) DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) { channel := GuideSourceChannel{} err := db.SQL.Get(&channel, `DELETE FROM guide_source_channel WHERE id = $1`, channelID) return &channel, err } // UpdateGuideSourceChannel updates a channel. -func (db *GuideSourceChannelDB) UpdateGuideSourceChannel(channelID, description string) (*GuideSourceChannel, error) { +func (db *GuideSourceChannelDB) UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) { channel := GuideSourceChannel{} err := db.SQL.Get(&channel, `UPDATE guide_source_channel SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) return &channel, err diff --git a/models/lineup.go b/models/lineup.go index 85efe14..ecfe994 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -69,24 +69,24 @@ func (d *DiscoveryData) UPNP() upnp.RootDevice { } type SQLLineup struct { - ID int `db:"id" json:"id"` - Name string `db:"name" json:"name"` - SSDP bool `db:"ssdp" json:"ssdp"` - ListenAddress string `db:"listen_address" json:"listenAddress"` - DiscoveryAddress string `db:"discovery_address" json:"discoveryAddress"` - Port int `db:"port" json:"port"` - Tuners int `db:"tuners" json:"tuners"` - Manufacturer string `db:"manufacturer" json:"manufacturer"` - ModelName string `db:"model_name" json:"modelName"` - ModelNumber string `db:"model_number" json:"modelNumber"` - FirmwareName string `db:"firmware_name" json:"firmwareName"` - FirmwareVersion string `db:"firmware_version" json:"firmwareVersion"` - DeviceID string `db:"device_id" json:"deviceID"` - DeviceAuth string `db:"device_auth" json:"deviceAuth"` - DeviceUUID string `db:"device_uuid" json:"deviceUUID"` - CreatedAt *time.Time `db:"created_at" json:"createdAt"` - - Channels []LineupChannel `json:"channels"` + ID int `db:"id"` + Name string `db:"name"` + SSDP bool `db:"ssdp"` + ListenAddress string `db:"listen_address"` + DiscoveryAddress string `db:"discovery_address"` + Port int `db:"port"` + Tuners int `db:"tuners"` + Manufacturer string `db:"manufacturer"` + ModelName string `db:"model_name"` + ModelNumber string `db:"model_number"` + FirmwareName string `db:"firmware_name"` + FirmwareVersion string `db:"firmware_version"` + DeviceID string `db:"device_id"` + DeviceAuth string `db:"device_auth"` + DeviceUUID string `db:"device_uuid"` + CreatedAt *time.Time `db:"created_at"` + + Channels []LineupChannel } func (s *SQLLineup) GetDiscoveryData() DiscoveryData { @@ -110,9 +110,9 @@ func (s *SQLLineup) GetDiscoveryData() DiscoveryData { // LineupAPI contains all methods for the User struct type LineupAPI interface { InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) - DeleteLineup(lineupID string) (*SQLLineup, error) - UpdateLineup(lineupID, description string) (*SQLLineup, error) - GetLineupByID(id string) (*SQLLineup, error) + DeleteLineup(lineupID int) (*SQLLineup, error) + UpdateLineup(lineupID int, description string) (*SQLLineup, error) + GetLineupByID(id int, withChannels bool) (*SQLLineup, error) GetEnabledLineups(withChannels bool) ([]SQLLineup, error) } @@ -154,21 +154,28 @@ func (db *LineupDB) InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) { } // GetLineupByID returns a single Lineup for the given ID. -func (db *LineupDB) GetLineupByID(id string) (*SQLLineup, error) { +func (db *LineupDB) GetLineupByID(id int, withChannels bool) (*SQLLineup, error) { var lineup SQLLineup err := db.SQL.Get(&lineup, fmt.Sprintf(`%s WHERE L.id = $1`, baseLineupQuery), id) + if withChannels { + channels, channelsErr := db.Collection.LineupChannel.GetChannelsForLineup(lineup.ID, true) + if channelsErr != nil { + return nil, channelsErr + } + lineup.Channels = channels + } return &lineup, err } // DeleteLineup marks a lineup with the given ID as deleted. -func (db *LineupDB) DeleteLineup(lineupID string) (*SQLLineup, error) { +func (db *LineupDB) DeleteLineup(lineupID int) (*SQLLineup, error) { lineup := SQLLineup{} err := db.SQL.Get(&lineup, `DELETE FROM lineup WHERE id = $1`, lineupID) return &lineup, err } // UpdateLineup updates a lineup. -func (db *LineupDB) UpdateLineup(lineupID, description string) (*SQLLineup, error) { +func (db *LineupDB) UpdateLineup(lineupID int, description string) (*SQLLineup, error) { lineup := SQLLineup{} err := db.SQL.Get(&lineup, `UPDATE lineup SET description = $2 WHERE id = $1 RETURNING *`, lineupID, description) return &lineup, err @@ -179,16 +186,11 @@ func (db *LineupDB) GetEnabledLineups(withChannels bool) ([]SQLLineup, error) { lineups := make([]SQLLineup, 0) err := db.SQL.Select(&lineups, baseLineupQuery) if withChannels { - // newLineups := make([]SQLLineup, len(lineups)) for idx, lineup := range lineups { channels, channelsErr := db.Collection.LineupChannel.GetChannelsForLineup(lineup.ID, true) if channelsErr != nil { return nil, channelsErr } - // lineup.HDHRItems = make([]HDHomeRunLineupItem, 0) - // for _, channel := range channels { - // lineup.HDHRItems = append(lineup.HDHRItems, channel.HDHomeRunLineupItem()) - // } lineup.Channels = channels lineups[idx] = lineup } diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 4eadddd..a83f06f 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -2,7 +2,6 @@ package models import ( "fmt" - "strconv" "time" "github.com/jmoiron/sqlx" @@ -30,31 +29,31 @@ func (db *LineupChannelDB) tableName() string { } type LineupChannel struct { - ID int `db:"id" json:"id"` - LineupID int `db:"lineup_id" json:"lineupID"` - Title string `db:"title" json:"title"` - ChannelNumber string `db:"channel_number" json:"channelNumber"` - VideoTrackID int `db:"video_track_id" json:"videoTrackID"` - GuideChannelID int `db:"guide_channel_id" json:"guideChannelID"` - HighDefinition bool `db:"hd" json:"hd"` - Favorite bool `db:"favorite" json:"favorite"` - CreatedAt *time.Time `db:"created_at" json:"createdAt"` - - VideoTrack *VideoSourceTrack `json:"videoSourceTrack"` - GuideChannel *GuideSourceChannel `json:"guideSourceChannel"` + ID int `db:"id"` + LineupID int `db:"lineup_id"` + Title string `db:"title"` + ChannelNumber string `db:"channel_number"` + VideoTrackID int `db:"video_track_id"` + GuideChannelID int `db:"guide_channel_id"` + HighDefinition bool `db:"hd" json:"HD"` + Favorite bool `db:"favorite"` + CreatedAt *time.Time `db:"created_at"` + + VideoTrack *VideoSourceTrack + GuideChannel *GuideSourceChannel HDHR *HDHomeRunLineupItem lineup *SQLLineup } func (l *LineupChannel) Fill(api *APICollection) { - gChannel, gChannelErr := api.GuideSourceChannel.GetGuideSourceChannelByID(strconv.Itoa(l.GuideChannelID)) + gChannel, gChannelErr := api.GuideSourceChannel.GetGuideSourceChannelByID(l.GuideChannelID, true) if gChannelErr != nil { log.WithError(gChannelErr).Panicln("error getting channel during LineupChannel fill") return } l.GuideChannel = gChannel - vTrack, vTrackErr := api.VideoSourceTrack.GetVideoSourceTrackByID(strconv.Itoa(l.VideoTrackID)) + vTrack, vTrackErr := api.VideoSourceTrack.GetVideoSourceTrackByID(l.VideoTrackID, true) if vTrackErr != nil { log.WithError(vTrackErr).Panicln("error getting track during LineupChannel fill") return @@ -77,9 +76,9 @@ func (l *LineupChannel) HDHomeRunLineupItem() *HDHomeRunLineupItem { // LineupChannelAPI contains all methods for the User struct type LineupChannelAPI interface { InsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) - DeleteLineupChannel(channelID string) (*LineupChannel, error) - UpdateLineupChannel(channelID, description string) (*LineupChannel, error) - GetLineupChannelByID(id string) (*LineupChannel, error) + DeleteLineupChannel(channelID int) (*LineupChannel, error) + UpdateLineupChannel(channelID int, description string) (*LineupChannel, error) + GetLineupChannelByID(id int) (*LineupChannel, error) GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) } @@ -114,7 +113,7 @@ func (db *LineupChannelDB) InsertLineupChannel(channelStruct LineupChannel) (*Li } // GetLineupChannelByID returns a single LineupChannel for the given ID. -func (db *LineupChannelDB) GetLineupChannelByID(id string) (*LineupChannel, error) { +func (db *LineupChannelDB) GetLineupChannelByID(id int) (*LineupChannel, error) { var channel LineupChannel err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE C.id = $1`, baseLineupChannelQuery), id) if err != nil { @@ -122,7 +121,7 @@ func (db *LineupChannelDB) GetLineupChannelByID(id string) (*LineupChannel, erro } // Need to get the address and port number to properly fill - lineup, lineupErr := db.Collection.Lineup.GetLineupByID(strconv.Itoa(channel.LineupID)) + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(channel.LineupID, false) if lineupErr != nil { return nil, lineupErr } @@ -134,14 +133,14 @@ func (db *LineupChannelDB) GetLineupChannelByID(id string) (*LineupChannel, erro } // DeleteLineupChannel marks a channel with the given ID as deleted. -func (db *LineupChannelDB) DeleteLineupChannel(channelID string) (*LineupChannel, error) { +func (db *LineupChannelDB) DeleteLineupChannel(channelID int) (*LineupChannel, error) { channel := LineupChannel{} err := db.SQL.Get(&channel, `DELETE FROM lineup_channel WHERE id = $1`, channelID) return &channel, err } // UpdateLineupChannel updates a channel. -func (db *LineupChannelDB) UpdateLineupChannel(channelID, description string) (*LineupChannel, error) { +func (db *LineupChannelDB) UpdateLineupChannel(channelID int, description string) (*LineupChannel, error) { channel := LineupChannel{} err := db.SQL.Get(&channel, `UPDATE lineup_channel SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) return &channel, err @@ -156,7 +155,7 @@ func (db *LineupChannelDB) GetChannelsForLineup(lineupID int, expanded bool) ([] } if expanded { // Need to get the address and port number to properly fill - lineup, lineupErr := db.Collection.Lineup.GetLineupByID(strconv.Itoa(lineupID)) + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(lineupID, false) if lineupErr != nil { return nil, lineupErr } diff --git a/models/old_lineup.go b/models/old_lineup.go index 602914f..061bc48 100644 --- a/models/old_lineup.go +++ b/models/old_lineup.go @@ -23,6 +23,7 @@ import ( // var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString // var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString // var hdRegex = regexp.MustCompile(`hd|4k`) +// var plexXMLTVNSRegex = regexp.MustCompile(`([0-9]+)?(/[0-9]+)?[ ]*\\.[ ]*([0-9]+)?(/[0-9]+)?[ ]*\\.[ ]*([0-9]+)?(/[0-9]+)?`) var xmlNSRegex = regexp.MustCompile(`(\d).(\d).(?:(\d)/(\d))?`) var ddProgIDRegex = regexp.MustCompile(`(?m)(EP|SH|MV|SP)(\d{7,8}).(\d+).?(?:(\d).(\d))?`) diff --git a/models/video_source.go b/models/video_source.go index 6282deb..e3c2533 100644 --- a/models/video_source.go +++ b/models/video_source.go @@ -30,16 +30,16 @@ func (db *VideoSourceDB) tableName() string { } type VideoSource struct { - ID int `db:"id" json:"id,omitempty"` - Name string `db:"name" json:"name,omitempty"` - Provider string `db:"provider" json:"provider,omitempty"` - Username string `db:"username" json:"username,omitempty"` - Password string `db:"password" json:"password,omitempty"` - M3UURL string `db:"m3u_url" json:"m3uURL,omitempty"` - MaxStreams int `db:"max_streams" json:"maxStreams,omitempty"` - ImportedAt *time.Time `db:"imported_at" json:"importedAt,omitempty"` + ID int `db:"id"` + Name string `db:"name"` + Provider string `db:"provider"` + Username string `db:"username"` + Password string `db:"password"` + M3UURL string `db:"m3u_url"` + MaxStreams int `db:"max_streams"` + ImportedAt *time.Time `db:"imported_at"` - Tracks []VideoSourceTrack `db:"tracks" json:"tracks,omitempty"` + Tracks []VideoSourceTrack `db:"tracks"` } func (v *VideoSource) ProviderConfiguration() *providers.Configuration { @@ -55,9 +55,9 @@ func (v *VideoSource) ProviderConfiguration() *providers.Configuration { // VideoSourceAPI contains all methods for the User struct type VideoSourceAPI interface { InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) - DeleteVideoSource(videoSourceID string) (*VideoSource, error) - UpdateVideoSource(videoSourceID, description string) (*VideoSource, error) - GetVideoSourceByID(id string) (*VideoSource, error) + DeleteVideoSource(videoSourceID int) (*VideoSource, error) + UpdateVideoSource(videoSourceID int, description string) (*VideoSource, error) + GetVideoSourceByID(id int) (*VideoSource, error) GetAllVideoSources(includeTracks bool) ([]VideoSource, error) } @@ -91,21 +91,21 @@ func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*Vide } // GetVideoSourceByID returns a single VideoSource for the given ID. -func (db *VideoSourceDB) GetVideoSourceByID(id string) (*VideoSource, error) { +func (db *VideoSourceDB) GetVideoSourceByID(id int) (*VideoSource, error) { var videoSource VideoSource err := db.SQL.Get(&videoSource, fmt.Sprintf(`%s WHERE V.id = $1`, baseVideoSourceQuery), id) return &videoSource, err } // DeleteVideoSource marks a videoSource with the given ID as deleted. -func (db *VideoSourceDB) DeleteVideoSource(videoSourceID string) (*VideoSource, error) { +func (db *VideoSourceDB) DeleteVideoSource(videoSourceID int) (*VideoSource, error) { videoSource := VideoSource{} err := db.SQL.Get(&videoSource, `DELETE FROM video_source WHERE id = $1`, videoSourceID) return &videoSource, err } // UpdateVideoSource updates a videoSource. -func (db *VideoSourceDB) UpdateVideoSource(videoSourceID, description string) (*VideoSource, error) { +func (db *VideoSourceDB) UpdateVideoSource(videoSourceID int, description string) (*VideoSource, error) { videoSource := VideoSource{} err := db.SQL.Get(&videoSource, `UPDATE video_source SET description = $2 WHERE id = $1 RETURNING *`, videoSourceID, description) return &videoSource, err diff --git a/models/video_source_track.go b/models/video_source_track.go index e011dcf..a61c17e 100644 --- a/models/video_source_track.go +++ b/models/video_source_track.go @@ -36,16 +36,19 @@ type VideoSourceTrack struct { Tags json.RawMessage `db:"tags"` RawLine string `db:"raw_line"` StreamURL string `db:"stream_url"` - HighDefinition bool `db:"hd"` + HighDefinition bool `db:"hd" json:"HD"` ImportedAt *time.Time `db:"imported_at"` + + VideoSource *VideoSource + VideoSourceName string } // VideoSourceTrackAPI contains all methods for the User struct type VideoSourceTrackAPI interface { InsertVideoSourceTrack(trackStruct VideoSourceTrack) (*VideoSourceTrack, error) - DeleteVideoSourceTrack(trackID string) (*VideoSourceTrack, error) - UpdateVideoSourceTrack(trackID, description string) (*VideoSourceTrack, error) - GetVideoSourceTrackByID(id string) (*VideoSourceTrack, error) + DeleteVideoSourceTrack(trackID int) (*VideoSourceTrack, error) + UpdateVideoSourceTrack(trackID int, description string) (*VideoSourceTrack, error) + GetVideoSourceTrackByID(id int, expanded bool) (*VideoSourceTrack, error) GetTracksForVideoSource(videoSourceID int) ([]VideoSourceTrack, error) } @@ -79,21 +82,28 @@ func (db *VideoSourceTrackDB) InsertVideoSourceTrack(trackStruct VideoSourceTrac } // GetVideoSourceTrackByID returns a single VideoSourceTrack for the given ID. -func (db *VideoSourceTrackDB) GetVideoSourceTrackByID(id string) (*VideoSourceTrack, error) { +func (db *VideoSourceTrackDB) GetVideoSourceTrackByID(id int, expanded bool) (*VideoSourceTrack, error) { var track VideoSourceTrack err := db.SQL.Get(&track, fmt.Sprintf(`%s WHERE T.id = $1`, baseVideoSourceTrackQuery), id) + if expanded { + video, videoErr := db.Collection.VideoSource.GetVideoSourceByID(track.VideoSourceID) + if videoErr != nil { + return nil, videoErr + } + track.VideoSource = video + } return &track, err } // DeleteVideoSourceTrack marks a track with the given ID as deleted. -func (db *VideoSourceTrackDB) DeleteVideoSourceTrack(trackID string) (*VideoSourceTrack, error) { +func (db *VideoSourceTrackDB) DeleteVideoSourceTrack(trackID int) (*VideoSourceTrack, error) { track := VideoSourceTrack{} err := db.SQL.Get(&track, `DELETE FROM video_source_track WHERE id = $1`, trackID) return &track, err } // UpdateVideoSourceTrack updates a track. -func (db *VideoSourceTrackDB) UpdateVideoSourceTrack(trackID, description string) (*VideoSourceTrack, error) { +func (db *VideoSourceTrackDB) UpdateVideoSourceTrack(trackID int, description string) (*VideoSourceTrack, error) { track := VideoSourceTrack{} err := db.SQL.Get(&track, `UPDATE video_source_track SET description = $2 WHERE id = $1 RETURNING *`, trackID, description) return &track, err From b10c0281407a6761df0253a7ed6008ee084d9587 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Fri, 24 Aug 2018 00:46:16 -0700 Subject: [PATCH 053/182] Fix log line --- api/tuner.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/api/tuner.go b/api/tuner.go index f66d656..56a4438 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -167,7 +167,7 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return } - log.Infof("Serving channel number %s", channelID) + log.Infof("Serving channel number %d", channelID) if !viper.IsSet("iptv.ffmpeg") { c.Redirect(http.StatusMovedPermanently, channel.VideoTrack.StreamURL) From 4812a7c5acb9203ebc2a69539d78d3c6e1d402d5 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Fri, 24 Aug 2018 00:46:27 -0700 Subject: [PATCH 054/182] Update frontend --- api/a_api-packr.go | 6 +++--- frontend | 2 +- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index cecd855..8cbfcfb 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -7,12 +7,12 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"H4sIAAAAAAAA/+xU3W7bNhi951Mc5KoFVC8Ntq7YVRmLtohJpEDRzXwpS7TFTCYNkW6QPf1A2WmR7RGaK0Hf3/nO+YjT+cl8eAxf7ha/LX4nFddk6U/Pkz0MEe+697i7/fjrh7vbj5+RG2cD6nMY/m4n842Q2kxHG4L1DjZgMJPZPeMwtS6aPsN+MgZ+j25op4PJED1a94yTmYJ38LvYWmfdAS06f3omfo842IDg9/GpnQxa16MNwXe2jaZH77vz0bjYxoS3t6MJeBcHg5vm2nHzfgbpTTsS65ByLyk82Tj4c8RkQpxsl2ZksK4bz33a4SU92qO9IqT2WYVAosc5mGzeM8PR93afvmamdTrvRhuGDL1No3fnaDKEFOyMS12t63/xE4IZR9L5kzUBM9cf2801afVTEjReJQop8jT442smNpD9eXI2DGbu6T2CnxEfTRdTJJXv/Tj6p0St8663iVH4gxA9GLQ7/83MXC5Hdj7a7iL3fIDTj6teU2FoxxE7cxXM9LCOpNALnSnBh9i6aNsRJz/NeP+luSBEFwyNXOkHqhh4g1rJrzxnOW5oA97cZHjgupAbjQeqFBV6C7kCFVv8yUWegf1VK9Y0kIrwqi45yzNwsSw3ORdr3G80hNQoecU1y6ElEuB1FGdNGlYxtSyo0PSel1xvM7LiWqSZK6lAUVOl+XJTUoV6o2rZMFCRQ0jBxUpxsWYVE3oBLiAk2FcmNJqClmWCInSjC6nSfljKeqv4utAoZJkz1eCeoeT0vmQXKLHFsqS8ypDTiq7Z3CV1wRRJZZft8FCwFEp4VIAuNZci0VhKoRVd6gxaKv299YE3LANVvEmCrJSsMpLklKtUwkXqE+wyJUmNVxeRav7fNOz7QOSMllysG3Dx6nwLQv7xziwew5fbxefF3afZO9IDq7hGeXn95P9m8uliJmvvD6PJwF23eHOSNyd5c5Kf10n+DQAA//82zaErgwgAAA==\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"H4sIAAAAAAAA/+xa3ZMbN3J/51/RYVUqu1UjWlbOPp/9YmqXkiZZkVskZZ0qlQdwpoeEhQHmAMxyeX99qhvAfJCUrKo8pWI92Etypr/71x9AYSy++N39+mr2w+yvk/f5dnJnmpOV+4OHm+IWXr38/i8vXr38/ie4Ry0dPLbu8FlYfJpMHtHW0jlpNEgHB7S4O8HeCu2xzKCyiGAqKA7C7jEDb0DoEzRondFgdl5ILfUeBBSmOU1MBf4gHThT+aOwCEKXIJwzhRQeSyhN0daovfDEr5IKHdz4A8J0E9+Y3jKTEoWaSA30W/oJjtIfTOvBovNWFkQjA6kL1ZYkQ/pZyVpGDvQ6W8FNvIHWYcZyZlCbUlb0f2S1mnanpDtkUEoivWs9ZuDoywI1vSV0+Z2x4FCpSWEaiQ5Y1146foZEb8igPprI0TfHg6nHmkg3qVqrpTsgv1MacIY5/o6Fp2/o8cooZY6kWmF0KUkj9/Nksj0giJ15QtYlOFkbL4tgbnZA03s1/uQOQinYYTQYliD1hL5K6lhi77zQXgoFjbHM71zN2WSyfbeAzerN9uN8vYB8A4/r1W/5/eIepvMN5JtpBh/z7bvVhy18nK/X8+X2E6zewHz5Cf4zX95nsPj743qx2cBqPcnfPz7ki/sM8uXdw4f7fPkWXn/YwnK1hYf8fb5d3MN2BcQwksoXGyL2frG+ezdfbuev84d8+ymbvMm3S6L5ZrWGOTzO19v87sPDfA2PH9aPq80C5st7WK6W+fLNOl++XbxfLLczyJewXMHit8VyC5t384cHYjWZf9i+W61JPrhbPX5a52/fbeHd6uF+sd7A6wU85PPXD4vAavkJ7h7m+fsM7ufv528X/NZq+26xntBjQTr4+G5BXxG/+RLmd9t8tSQ17lbL7Xp+t81gu1pvu1c/5ptFBvN1viGDvFmv3mcTMufqDT2SL+m95SJQIVPDyCOrNX/+sFl0BOF+MX/Il283kC9H7ptNJv80Gme/u19fzn6avfqRsYMC7H2+hYcQ/ZNLMPkxgMlbY/YKM8h1MfsTSf5Ekj+R5P8zktjn392vP85ezV5N5o0oDvji1exl/LPDEvjSv9/QcpC9mr3M4D+EboU9wauXL//yhVcO3jc/f/fd8XicCWYxM3b/XUwz991kAtvF+v2G3XW3Wt7npGRw6wcyynrxuF7df2DdM37qPt9s1/nrD/TNZALfz+AeK6lDtswmLMc06jGNWVCjCNjg0daOs6bPMKiMDVBhsbGmbAPQMCF6soMI0ls4KIkdlrA7wQaLQOJ78Adr2v0B/gYJExP2jWUy9kKoPqvNUaOlzETtpT+BaP3BWPlP5sZUrj3vD8ITljOIE3r43pMdc9wLBQsmeyFAq0m1mPiiYBpJAsJzpZiI8QeMohGAMNvCaG+NyoBQLn5QLG5GetC3rS7RQmHq2mimEx9j/A5UArMZvDGWZWha2xiXMFdGm8veL9NIY8pKOLiRt+FFc0RLqG4JVo0FqcPfXGQK0Tqk55hG+IE1t1ALLfZI7iKeri0OUagMjgdkxXenILlgyr1FjpJix1i4kfI2uMQdZEN0Kll5Lp4FEb754eW/3jIzYzGaO5BpPeEwFzV3EBZdoidvYYcaK1kQRo9oD2RMTv5k2incGMt/2ent0M9Csy2eZNkSJQvDiODX8RltIR0J0VcTl1oDUp9dcRZYG9PaAqeURPV5XDUWK7QWy/BrxXb+TAy4HMuCi7YLLu3r+q7l+hbqeqiXXX/hmB0UpsRs3F0wkfBzljK8kvvWDnqPJPSKy+6l0NTq8HcWXas4DypraqixOAgtCxESwVuhHT0nUvjwNyp+rEBAMAsTy8aqMYUz9QpTN5LSxoR+IKi3R432so3qkakw+ingMbcdIT9rLKUAf2p6dT8a+/ki6Y/GfmZZGWMoqvpQlzopEAM9GCyqU4sSQTwJqcROpfweYE5GKEnBVogYOCLm/Vn3koBr0KEwaHhPlaJMbRFJygRuhAZ8FnWjqKOCxponGV+j5+ZNg7qUz7BDZY63Sft7tPJJePmEQIZw03OPE/3ruke9mU7QPYm8E47cpTndSuJAUW5NHXCIGLGLKOaPB1kcumTHUnpjKZ0tPkl2HsWrNj5mA6ASO2PTJ2OTY4c5w6SoXqFD7dnigvpOxcEPxsq91EJd8fIlygYMqkbpncG52aLVKHKjv5h4rAMWayFjDmIjLEcG2YMVqNGiOoGS+jMbbCc1x4UWNd4mN0vt0VaiYNjPumrXmfJCILIKmir5+Y7AOdbpqz4+j/YuLTtendliWqWa2MlApEZ+4HgtYycR6JhgEX7H2C+KnQ3C3xOOGy2UClDs2l0tfQSH1DdwLLHMYXjTvWiMzReNQfArF66vov+wzSCsZeYU2zs8CFWBqb7UenxbxYZpp8+UKYWa3YGtqQAVFt4aLYuMbL8TiuPmaOktzc1Dq6PNgSK+NzX2BiL7eNenBVvdZV8tLRGZhvSNHsgDtZCKXlXSeZcNC1DXyLiT81i7Hpilcy1SUSi42sXfg8OpioVuo+uShqbOOqAY+X1gY7JXKV3ROq7VzK9mLIyt30fGs1Rq8DkpP9YyRV9htGtk0ZrWqRPUwn4mYLN9bxOaJXRyrxnPpWa/sDmvxh2B0XRpPAgY5uRsep6oZ71wp3DKtD9oWIZmCzP3mCEchIMdogaLBTJC704jLinZHP6jRe0VsSyMbUwou9SgDtKMgObVDN5SQ0Qs+31L6olgMx7or44bXToN0RZFcYCBYUaLGa7un0wLgjqzBn0rVAi2o7GqPErqFrTRL9jXTj7xxxdph2PNSSh/elFZxAyktfhkCgLos6ocpzJiliYhzKiJayhmL3AsgTTvUgp1oqBslDhl/TcN2lA2z1Yrg7VLF+4dxnJje8HtSllm9CCn/PvAKY+CwPT/tEdu8LnAxlMaOZ9SLqzZwsByC03QcuCxWnzGDA7iCbk/C8LwVGuqivozw8usLP5X1o2xPjijy/TY2MZujmEk6ESqB78kjqJpFG+RtDoF2xIyRbEKJWTt4rOdWrtTIDG0aYeIGgt0TljJOVhZqfdp5kAZKtkwtW/cLQhlNMb6Vph6J3XXf/NL5y8EVcLMGesm7+qoORsLFhkcyQGpcs0gr8jjcVZxXnqK3s4RXu4De7EX9DMDWByib/oCFDtha5x7wWYiBQrTUu8TPksNApQ4ulZ6UlLhPgC78J3gqbKf4d3XwItxPgjt4uibqBS9Q05JoeSDmrtLf8DQRo3jLjQ8aUCMGZHGgT6XYgFLPVFAfEpE8liIDdHtHUvhu1DrbCodz28lJftfZrDG4U5mxmxrcepR6xxjRhvcHm2+0p2xG6jZw1K2dRbihjqSsHMObcxoiA2F+AsolfXDChsiBVKN6L+2+g1Tz23QsHUe9iQpCRZmAouFbCQSIA1b1Ti10b8LBcPm/rzf/4XLYeC3G/ALK5O+7aUph7f4vE6xFDDW1FJTVISpznWsCby60CWKNETv2QQYqAy5FgOuFr2QvOuPu+humOYeXp8u1OqYdsyGm/249g51LotRnBHclUgdT9Y1AxyMvk+pqFNYA1yRZQyU434rYGKiwIKVhtvPBi0p2J2uCOtTEUqd9rmCQ1OVtwRGnbfjOEaunS5X2/xuMQWPz55tTKkV6VNz3PEYZtAgwa/kw4U92UcdoTQMCrAoSp77+gDDq8YkwBFSY2/yCFac90EFFj77Fmt2RK5b9ao1ObSEB4XC0ajTb7zjC30+NopG0p+TiCLJ11u4t8wghtxX+f8yhOdRSPWZO176gKx6DKHSt+9r2SV1Y7Nz24rUnw32SrF/v2KdapQR3AA8oQ0O8gdpyxek3qnzhza2pvGVGgMUdgbbQ5iPCJvOjTvwMBf/MNh2CzWhBuMk9RdDUWIGhfO80aa7KwOiLOlvS9PIMP46GknoaJlvifks2NzJchAqPOkITQxRl22dmsxRhCTgCFNZcuEYr9isaY0g1PWk4R0R7DBUctuOoy0Y5Pr2/6ph+r6fm0xefYcSfrZq6sxPJKL8Q2GNhVJSjznqSK/02WmNduWwJRAZnLOY6ookWUqPise30xdGheEurEsZpkaMu81Zz/zilGdUS7vuuDB1aHopbgYrkW6OOOvWB074gQeRdELLs2Pft7kZfNAKnWNH4XOjZCFpGGV6g0OGuF84nXd9g/XRYHX0xXVR6saJ2/kKpTs17re63z4ypQN5EnEQIIFAaDTLdE5Hby+Np1e6sw+fDrppWKLU3PPQRYWBxXJtg9ZhieEQhQK+c0NkErqDsIL02I8re4shxE8xF3hSwmcsOthmOO0MYXEvbDiROZ8NeK/+4wy2qX1wBHeDfrc0jIg+tMbDs/lwKSEITG+HwwBRoxt0I46GNPskC4T40ViI8RoeTgGapM3SpieOjRb/0cp47kJl2RnNhZmd2DpvamFPLInUUKIrrNxFB8ShQO7l5fYzZU3yVcT3K7BOFvrrDO6l46EGLT3zUViyx6kL907M3SkMlDwD0/CTEp39xqNFv3XKeifF7Ha9mDckJ43u45Fx+Kz0buzOWzB8PhavM8Dr+SbfBJOeXWzIF/GWQHdQPbrogDKckD43ltSLOkhGjXKwhsyuXF3Jwpo6mCjezziDTlPBNt8+LDJYrpYvhjcbsosLEvT66I4EU7i8JxGqZjhZU6hohnKN0U7y/p7PNsKkNgwP0TTWNFZSG82KVtDyLpKjrUfSwT4yXQxqa54mAghLx2jd3RbiDGSgjmeRvOscHkZeDpcUaT/N4KG/A2QqeJBiJxUfKedUQQGfKE5JhkBBG1C8TvQHNPbUrTnSCZA31g/Hdo17JfeoC7zNulPgbLQmjRuXP4zsm1DsHZSo5I4bMRZsb41zcf+f2HkQhXd8Znw9EwIujkqCsbALblKSmca5nJ0parEfb8Tp3XRE3h+WuwYLmVZaUheypEY0LOWp/Qj7UilUIpmQtzgIMg1aEDacJVM1jjXXtcqfD55sw7bDkDZ8I3V04AAx+7n95qtnxUkiUliZEJ57Y8qjVP2O7jM4b5pG7PmGWN20JHIlpGptqC5CVa3umxMuaRd3IQpT1xSoQzsEpuhuM446aqXP115MoVtOi/JJ8mFiFa8wOCej8umYPxKnWP/bDOYF4TxpnxCVuM77gjsI/48HarLHSTk+WvvqEVXqHIuDMWHPyNvEwRE0bzRBQIWMFxkIlk7oAoP4TVg0RmQ7cZRhraWPWdedb6okNZidipsfly7ihUt9HHvScdGJ0490g8MSnME7c6RJJQx4naHYigOyvWZ8m0Or7kSh64/j0QIvSOPXBJE9QLKs3Kn0JxEJp/sNzcDtcdtKE42sAu5SUoecZptU0SYlVqjL8PzBqPLKMlrYmpEmtcKd9VLKttb2J0xxIyucQ0tpEpeU2eVGdneKDUNS5USa95bs2u7jIPYGzV4nBwXrYnlPFfLaFa/JBOaPj4vlff73n8lpPLU3jTrFo/zhdTT6jcU4xlMYANh+4+NZvE4wnupDC2ykQtsoQuAwZWX9TF1JVKUD1IUyLgD5zoriM3oH0//672kaI5QoUuU6pdBhtIzT2GCuncHNvdH/1p2fd3mYCP/LLfDczIOjO5hWldSKdzLEHn5QfrvTS8oId9JePHfHhTxeB+Yz+IgglDNgMTwd95ABmfnJECXOcYcZRiJuDJtUVNPx4/BKabhyG47R6LVpYyUvgwlZp4T94/PBePGDREThZDyjjvZKJ5PdaqRfMwhbHORTQMCLa84/XF5zzmCJvlLyOX18LwtrnKk83BnbzNI4k8LeTSYpesrB6DOOq2x4+zFeY04XDW9/mXSjBSFCqFlxb506c6njDMno2IVa18l0oBTuWY9WtX10Cx8y4I/uVj7kd4vlZsHXOyff1HJ/qcmIl68mw03X5bUfkG70wPWm+n/ZUaduejaBDeKIfYp77l0qWYASet+KPcLePKHV5xfbeK3RN+DuUqPZ/wQAAP//DytTlLEzAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5SRQXLzIAyF9zkFv9a/w7SrLsC9RC+gYDlWKoMHFCe+fQfTNjNdtSvQJ96T3uD+DSnotpCZdJb+4OphBOPZA0WogHDoD8a4mRRNmDAXUg9XHbsX2BvKKtS/kcjmbCsqPmEhM2UaPVh4OEScycPKdFtSVjAhRaWoHm486OQHWjlQtxf/DUdWRulKQCH/1GyE47vJJB44pAimru+BZzyTvXeNtbkjrrU8ckivq3+ucR7ioptQmYj063kjx1AK9M624O6Uhm0fi8vS5ZS0d/b7enAlZF70cwelu9oLrtgomJKDh3yNyjMdL7tta/W/ES5JtpFFyt+lM3L8obItibPtpz8CAAD//9U7Pon6AQAA\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/frontend b/frontend index 1f42871..7e45726 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 1f42871b14badb0d714bafccf01a10a581d0fed7 +Subproject commit 7e45726f6c171620c95fb1a46903c1b6630043c3 From 8baf47d380670754ce4060c1511524fde9d7d7e6 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Fri, 24 Aug 2018 18:09:00 -0700 Subject: [PATCH 055/182] Get upsert of lineup channels going, minor fixes --- api/lineup_channel.go | 26 +++++++++++++++++++++ api/main.go | 1 + api/tuner.go | 33 ++++++++++++--------------- models/lineup_channel.go | 49 +++++++++++++++++++++++++++------------- models/old_lineup.go | 10 ++++---- 5 files changed, 79 insertions(+), 40 deletions(-) diff --git a/api/lineup_channel.go b/api/lineup_channel.go index fa8e9df..1d4a92f 100644 --- a/api/lineup_channel.go +++ b/api/lineup_channel.go @@ -27,3 +27,29 @@ func addLineupChannel(lineup *models.SQLLineup, cc *context.CContext, c *gin.Con c.JSON(http.StatusOK, newChannel) } } + +func updateLineupChannels(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { + newChannels := make([]models.LineupChannel, 0) + if c.BindJSON(&newChannels) == nil { + for idx, channel := range newChannels { + channel.LineupID = lineup.ID + channel.GuideChannel = nil + channel.HDHR = nil + channel.VideoTrack = nil + log.Infof("GOT CHANNEL %+v", channel) + newChannel, lineupErr := cc.API.LineupChannel.UpsertLineupChannel(channel) + if lineupErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupErr) + return + } + newChannel.Fill(cc.API) + newChannels[idx] = *newChannel + } + + lineup.Channels = newChannels + + RestartTuner(cc, lineup) + + c.JSON(http.StatusOK, lineup) + } +} diff --git a/api/main.go b/api/main.go index f64793e..68891cf 100644 --- a/api/main.go +++ b/api/main.go @@ -46,6 +46,7 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/lineups", wrapContext(cc, getLineups)) apiGroup.POST("/lineups", wrapContext(cc, addLineup)) apiGroup.GET("/lineups/:lineupId", lineupRoute(cc, getLineup)) + apiGroup.PUT("/lineups/:lineupId/channels", lineupRoute(cc, updateLineupChannels)) apiGroup.POST("/lineups/:lineupId/channels", lineupRoute(cc, addLineupChannel)) apiGroup.GET("/lineup/scan", scanM3U) diff --git a/api/tuner.go b/api/tuner.go index 56a4438..aa3e10d 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -10,7 +10,6 @@ import ( "net/http" "os/exec" "regexp" - "strconv" "strings" "time" @@ -50,7 +49,7 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup router.POST("/lineup.post", scanChannels(lineup)) router.GET("/lineup.json", serveHDHRLineup(hdhrItems)) router.GET("/lineup.xml", serveHDHRLineup(hdhrItems)) - router.GET("/auto/:channelID", stream(cc, lineup)) + router.GET("/auto/:channelNumber", stream(cc, lineup)) baseAddr := fmt.Sprintf("%s:%d", lineup.ListenAddress, lineup.Port) @@ -135,8 +134,8 @@ func discovery(data models.DiscoveryData) gin.HandlerFunc { } type hdhrLineupContainer struct { - XMLName xml.Name `xml:"Lineup" json:"-"` - Programs []models.HDHomeRunLineupItem + XMLName xml.Name `xml:"Lineup" json:"-"` + Programs []models.HDHomeRunLineupItem `xml:"Program"` } func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { @@ -144,7 +143,7 @@ func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { if strings.HasSuffix(c.Request.URL.String(), ".xml") { buf, marshallErr := xml.MarshalIndent(hdhrLineupContainer{Programs: hdhrItems}, "", "\t") if marshallErr != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling lineup to XML")) + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling lineup to XML: %s", marshallErr)) } c.Data(http.StatusOK, "application/xml", []byte(``+"\n"+string(buf))) return @@ -155,19 +154,13 @@ func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return func(c *gin.Context) { - channelID, channelIDErr := strconv.Atoi(c.Param("channelID")[1:]) - if channelIDErr != nil { - c.AbortWithError(http.StatusBadRequest, channelIDErr) - return - } - - channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(channelID) + channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(lineup.ID, c.Param("channelNumber")[1:]) if channelErr != nil { c.AbortWithError(http.StatusInternalServerError, channelErr) return } - log.Infof("Serving channel number %d", channelID) + log.Infof("Serving channel number %s", channel.ChannelNumber) if !viper.IsSet("iptv.ffmpeg") { c.Redirect(http.StatusMovedPermanently, channel.VideoTrack.StreamURL) @@ -212,27 +205,29 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { continueStream := true - c.Stream(func(w io.Writer) bool { + streamVideo := func(w io.Writer) bool { defer func() { metrics.ActiveStreams.WithLabelValues(lineup.Name).Dec() - log.Infoln("Stopped streaming", channelID) + log.Infoln("Stopped streaming", channel.ChannelNumber) if killErr := run.Process.Kill(); killErr != nil { - panic(killErr) + log.WithError(killErr).Panicln("error when killing ffmpeg") } continueStream = false return }() if _, copyErr := io.Copy(w, ffmpegout); copyErr != nil { - log.WithError(copyErr).Errorln("Error when copying data") + log.WithError(copyErr).Errorln("error when streaming from ffmpeg to http") continueStream = false return false } return continueStream - }) + } + + c.Stream(streamVideo) return - c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %d", channelID)) + c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %d", channel.ChannelNumber)) } } diff --git a/models/lineup_channel.go b/models/lineup_channel.go index a83f06f..efbbffd 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -39,14 +39,25 @@ type LineupChannel struct { Favorite bool `db:"favorite"` CreatedAt *time.Time `db:"created_at"` - VideoTrack *VideoSourceTrack - GuideChannel *GuideSourceChannel - HDHR *HDHomeRunLineupItem + VideoTrack *VideoSourceTrack `json:",omitempty"` + GuideChannel *GuideSourceChannel `json:",omitempty"` + HDHR *HDHomeRunLineupItem `json:",omitempty"` lineup *SQLLineup } func (l *LineupChannel) Fill(api *APICollection) { + if l.lineup == nil { + // Need to get the address and port number to properly fill + lineup, lineupErr := api.Lineup.GetLineupByID(l.LineupID, false) + if lineupErr != nil { + log.WithError(lineupErr).Panicln("error getting lineup during LineupChannel fill") + return + } + + l.lineup = lineup + } + gChannel, gChannelErr := api.GuideSourceChannel.GetGuideSourceChannelByID(l.GuideChannelID, true) if gChannelErr != nil { log.WithError(gChannelErr).Panicln("error getting channel during LineupChannel fill") @@ -76,9 +87,10 @@ func (l *LineupChannel) HDHomeRunLineupItem() *HDHomeRunLineupItem { // LineupChannelAPI contains all methods for the User struct type LineupChannelAPI interface { InsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) + UpsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) DeleteLineupChannel(channelID int) (*LineupChannel, error) - UpdateLineupChannel(channelID int, description string) (*LineupChannel, error) - GetLineupChannelByID(id int) (*LineupChannel, error) + UpdateLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) + GetLineupChannelByID(lineupID int, channelNumber string) (*LineupChannel, error) GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) } @@ -112,21 +124,22 @@ func (db *LineupChannelDB) InsertLineupChannel(channelStruct LineupChannel) (*Li return &channel, err } +// UpsertLineupChannel upserts a LineupChannel in the database. +func (db *LineupChannelDB) UpsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) { + if channelStruct.ID != 0 { + return db.UpdateLineupChannel(channelStruct) + } + return db.InsertLineupChannel(channelStruct) +} + // GetLineupChannelByID returns a single LineupChannel for the given ID. -func (db *LineupChannelDB) GetLineupChannelByID(id int) (*LineupChannel, error) { +func (db *LineupChannelDB) GetLineupChannelByID(lineupID int, channelNumber string) (*LineupChannel, error) { var channel LineupChannel - err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE C.id = $1`, baseLineupChannelQuery), id) + err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE C.lineup_id = $1 AND C.channel_number = $2`, baseLineupChannelQuery), lineupID, channelNumber) if err != nil { return nil, err } - // Need to get the address and port number to properly fill - lineup, lineupErr := db.Collection.Lineup.GetLineupByID(channel.LineupID, false) - if lineupErr != nil { - return nil, lineupErr - } - - channel.lineup = lineup channel.Fill(db.Collection) return &channel, err @@ -140,9 +153,13 @@ func (db *LineupChannelDB) DeleteLineupChannel(channelID int) (*LineupChannel, e } // UpdateLineupChannel updates a channel. -func (db *LineupChannelDB) UpdateLineupChannel(channelID int, description string) (*LineupChannel, error) { +func (db *LineupChannelDB) UpdateLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) { channel := LineupChannel{} - err := db.SQL.Get(&channel, `UPDATE lineup_channel SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) + _, err := db.SQL.NamedExec(`UPDATE lineup_channel SET lineup_id = :lineup_id, title = :title, channel_number = :channel_number, video_track_id = :video_track_id, guide_channel_id = :guide_channel_id, favorite = :favorite, hd =:hd WHERE id = :id`, channelStruct) + if err != nil { + return &channel, err + } + err = db.SQL.Get(&channel, "SELECT * FROM lineup_channel WHERE id = $1", channelStruct.ID) return &channel, err } diff --git a/models/old_lineup.go b/models/old_lineup.go index 061bc48..b75bd7e 100644 --- a/models/old_lineup.go +++ b/models/old_lineup.go @@ -31,16 +31,16 @@ var ddProgIDRegex = regexp.MustCompile(`(?m)(EP|SH|MV|SP)(\d{7,8}).(\d+).?(?:(\d type HDHomeRunLineupItem struct { XMLName xml.Name `xml:"Program" json:"-"` AudioCodec string `xml:",omitempty" json:",omitempty"` - DRM ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` - Favorite ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` + DRM ConvertibleBoolean `xml:",omitempty" json:",omitempty"` + Favorite ConvertibleBoolean `xml:",omitempty" json:",omitempty"` GuideName string `xml:",omitempty" json:",omitempty"` GuideNumber string `xml:",omitempty" json:",omitempty"` - HD ConvertibleBoolean `xml:",omitempty" json:",string,omitempty"` + HD ConvertibleBoolean `xml:",omitempty" json:",omitempty"` URL string `xml:",omitempty" json:",omitempty"` VideoCodec string `xml:",omitempty" json:",omitempty"` - provider providers.Provider - ProviderChannel providers.ProviderChannel `json:"-"` + provider providers.Provider `xml:"-"` + ProviderChannel providers.ProviderChannel `xml:"-" json:"-"` } func newHDHRItem(provider *providers.Provider, ProviderChannel *providers.ProviderChannel) HDHomeRunLineupItem { From d1c8599aec49d5fd3b8eb2f4d424578d8e836692 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Fri, 24 Aug 2018 23:48:06 -0700 Subject: [PATCH 056/182] Checkpoint: working epg.xml, add support for XMLTV programmes, change some xmltv package fields and formatting, more generate improvements --- api/guide_source.go | 41 +++++--- api/main.go | 1 + api/xmltv.go | 46 +++++--- frontend | 2 +- internal/xmltv/xmltv.go | 34 +++--- migrations/00001_init.sql | 20 +++- models/guide_source_channel.go | 56 ++++++---- models/guide_source_programme.go | 174 +++++++++++++++++++++++++++++++ models/main.go | 14 +-- models/old_lineup.go | 4 +- 10 files changed, 305 insertions(+), 87 deletions(-) create mode 100644 models/guide_source_programme.go diff --git a/api/guide_source.go b/api/guide_source.go index 1a7ff44..b2f7f92 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -1,9 +1,7 @@ package api import ( - "encoding/json" "net/http" - "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" @@ -13,13 +11,13 @@ import ( func addGuide(cc *context.CContext, c *gin.Context) { var payload models.GuideSource if c.BindJSON(&payload) == nil { - newProvider, providerErr := cc.API.GuideSource.InsertGuideSource(payload) + newGuide, providerErr := cc.API.GuideSource.InsertGuideSource(payload) if providerErr != nil { c.AbortWithError(http.StatusInternalServerError, providerErr) return } - providerCfg := newProvider.ProviderConfiguration() + providerCfg := newGuide.ProviderConfiguration() log.Infof("providerCfg %+v", providerCfg) @@ -39,25 +37,25 @@ func addGuide(cc *context.CContext, c *gin.Context) { } for _, channel := range xmlTV.Channels { - displayNames, _ := json.Marshal(channel.DisplayNames) - urls, _ := json.Marshal(channel.URLs) - icons, _ := json.Marshal(channel.Icons) - newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(models.GuideSourceChannel{ - GuideID: newProvider.ID, - XMLTVID: channel.ID, - DisplayNames: displayNames, - URLs: urls, - Icons: icons, - ChannelNumber: strconv.Itoa(channel.LCN), - }) + newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(newGuide.ID, channel) if newChannelErr != nil { log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") c.AbortWithError(http.StatusInternalServerError, newChannelErr) return } - newProvider.Channels = append(newProvider.Channels, *newChannel) + newGuide.Channels = append(newGuide.Channels, *newChannel) } - c.JSON(http.StatusOK, newProvider) + // FIXME: Instead of importing _every_ programme when we add a new guide source, we should only import programmes for channels in a lineup. + // Otherwise, SQLite DB gets a lot bigger and harder to manage. + for _, programme := range xmlTV.Programmes { + _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(newGuide.ID, programme) + if programmeErr != nil { + log.WithError(programmeErr).Errorln("Error creating new guide source channel during programme import!") + c.AbortWithError(http.StatusInternalServerError, programmeErr) + return + } + } + c.JSON(http.StatusOK, newGuide) } } @@ -88,3 +86,12 @@ func getAllChannels(cc *context.CContext, c *gin.Context) { c.JSON(http.StatusOK, channels) } + +func getAllProgrammes(cc *context.CContext, c *gin.Context) { + programmes, programmesErr := cc.API.GuideSourceProgramme.GetProgrammesForGuideID(2) + if programmesErr != nil { + c.AbortWithError(http.StatusInternalServerError, programmesErr) + return + } + c.JSON(http.StatusOK, programmes) +} diff --git a/api/main.go b/api/main.go index 68891cf..b5ca707 100644 --- a/api/main.go +++ b/api/main.go @@ -53,6 +53,7 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/guide_sources", wrapContext(cc, getGuideSources)) apiGroup.POST("/guide_sources", wrapContext(cc, addGuide)) apiGroup.GET("/guide_sources/channels", wrapContext(cc, getAllChannels)) + apiGroup.GET("/guide_sources/programmes", wrapContext(cc, getAllProgrammes)) apiGroup.GET("/video_sources", wrapContext(cc, getVideoSources)) apiGroup.POST("/video_sources", wrapContext(cc, addVideoSource)) diff --git a/api/xmltv.go b/api/xmltv.go index d4e393c..fbf728e 100644 --- a/api/xmltv.go +++ b/api/xmltv.go @@ -5,6 +5,7 @@ import ( "fmt" "net/http" "sort" + "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" @@ -12,27 +13,40 @@ import ( ) func xmlTV(cc *context.CContext, c *gin.Context) { - // FIXME: Move this outside of the function stuff. epg := &xmltv.TV{ GeneratorInfoName: "telly", GeneratorInfoURL: "https://github.com/tellytv/telly", } - // FIXME: Not actually a lineup... - // lineup := &models.SQLLineup{} - - // lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(true) - // if lineupsErr != nil { - // c.AbortWithError(http.StatusInternalServerError, lineupsErr) - // return - // } - - // for _, channel := range lineup.Channels { - // if channel.ProviderChannel.EPGChannel != nil { - // epg.Channels = append(epg.Channels, *channel.ProviderChannel.EPGChannel) - // epg.Programmes = append(epg.Programmes, channel.ProviderChannel.EPGProgrammes...) - // } - // } + lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(true) + if lineupsErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupsErr) + return + } + + programmes, programmesErr := cc.API.GuideSourceProgramme.GetProgrammesForActiveChannels() + if programmesErr != nil { + c.AbortWithError(http.StatusInternalServerError, programmesErr) + return + } + + epgMatchMap := make(map[string]int) + + for _, lineup := range lineups { + for _, channel := range lineup.Channels { + epgMatchMap[channel.GuideChannel.XMLTVID] = channel.ID + epg.Channels = append(epg.Channels, xmltv.Channel{ + ID: strconv.Itoa(channel.ID), + DisplayNames: []xmltv.CommonElement{xmltv.CommonElement{Value: channel.Title}}, + LCN: channel.ChannelNumber, + }) + } + } + + for _, programme := range programmes { + programme.XMLTV.Channel = strconv.Itoa(epgMatchMap[programme.Channel]) + epg.Programmes = append(epg.Programmes, *programme.XMLTV) + } sort.Slice(epg.Channels, func(i, j int) bool { return epg.Channels[i].LCN < epg.Channels[j].LCN diff --git a/frontend b/frontend index 7e45726..017f5bf 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 7e45726f6c171620c95fb1a46903c1b6630043c3 +Subproject commit 017f5bf654b2ef925864db4ac11c97548693de53 diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 252b84c..541faf4 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -88,11 +88,11 @@ type TV struct { Channels []Channel `xml:"channel" json:"channels" db:"channels"` Programmes []Programme `xml:"programme" json:"programmes" db:"programmes"` Date string `xml:"date,attr,omitempty" json:"date,omitempty" db:"date,omitempty"` - SourceInfoURL string `xml:"source-info-url,attr,omitempty" json:"sourceInfoURL,omitempty" db:"source_info_url,omitempty"` - SourceInfoName string `xml:"source-info-name,attr,omitempty" json:"sourceInfoName,omitempty" db:"source_info_name,omitempty"` - SourceDataURL string `xml:"source-data-url,attr,omitempty" json:"sourceDataURL,omitempty" db:"source_data_url,omitempty"` - GeneratorInfoName string `xml:"generator-info-name,attr,omitempty" json:"generatorInfoName,omitempty" db:"generator_info_name,omitempty"` - GeneratorInfoURL string `xml:"generator-info-url,attr,omitempty" json:"generatorInfoURL,omitempty" db:"generator_info_url,omitempty"` + SourceInfoURL string `xml:"source-info-url,attr,omitempty" json:"sourceInfoURL,omitempty" db:"source_info_url,omitempty"` + SourceInfoName string `xml:"source-info-name,attr,omitempty" json:"sourceInfoName,omitempty" db:"source_info_name,omitempty"` + SourceDataURL string `xml:"source-data-url,attr,omitempty" json:"sourceDataURL,omitempty" db:"source_data_url,omitempty"` + GeneratorInfoName string `xml:"generator-info-name,attr,omitempty" json:"generatorInfoName,omitempty" db:"generator_info_name,omitempty"` + GeneratorInfoURL string `xml:"generator-info-url,attr,omitempty" json:"generatorInfoURL,omitempty" db:"generator_info_url,omitempty"` } // LoadXML loads the XMLTV XML from file. @@ -110,44 +110,44 @@ func (t *TV) LoadXML(f *os.File) error { // Channel details of a channel type Channel struct { - DisplayNames []CommonElement `xml:"display-name" json:"displayNames" db:"display_names" ` + DisplayNames []CommonElement `xml:"display-name" json:"displayNames" db:"display_names"` Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty" db:"icons,omitempty"` - URLs []string `xml:"url,omitempty" json:"urls,omitempty" db:"urls,omitempty" ` - ID string `xml:"id,attr" json:"id,omitempty" db:"id,omitempty" ` - LCN int `xml:"lcn" json:"lcn,omitempty" db:"lcn,omitempty"` // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. + URLs []string `xml:"url,omitempty" json:"urls,omitempty" db:"urls,omitempty"` + ID string `xml:"id,attr" json:"id,omitempty" db:"id,omitempty"` + LCN string `xml:"lcn" json:"lcn,omitempty" db:"lcn,omitempty"` // LCN is the local channel number. Plex will show it in place of the channel ID if it exists. } // Programme details of a single programme transmission type Programme struct { ID string `xml:"id,attr,omitempty" json:"id,omitempty" db:"id,omitempty"` // not defined by standard, but often present Titles []CommonElement `xml:"title" json:"titles" db:"titles"` - SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondaryTitles,omitempty" db:"secondary_titles,omitempty"` + SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondaryTitles,omitempty" db:"secondary_titles,omitempty"` Descriptions []CommonElement `xml:"desc,omitempty" json:"descriptions,omitempty" db:"descriptions,omitempty"` Credits *Credits `xml:"credits,omitempty" json:"credits,omitempty" db:"credits,omitempty"` Date Date `xml:"date,omitempty" json:"date,omitempty" db:"date,omitempty"` Categories []CommonElement `xml:"category,omitempty" json:"categories,omitempty" db:"categories,omitempty"` Keywords []CommonElement `xml:"keyword,omitempty" json:"keywords,omitempty" db:"keywords,omitempty"` Languages []CommonElement `xml:"language,omitempty" json:"languages,omitempty" db:"languages,omitempty"` - OrigLanguages []CommonElement `xml:"orig-language,omitempty" json:"origLanguages,omitempty" db:"orig_languages,omitempty"` + OrigLanguages []CommonElement `xml:"orig-language,omitempty" json:"origLanguages,omitempty" db:"orig_languages,omitempty"` Length *Length `xml:"length,omitempty" json:"length,omitempty" db:"length,omitempty"` Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty" db:"icons,omitempty"` URLs []string `xml:"url,omitempty" json:"urls,omitempty" db:"urls,omitempty"` Countries []CommonElement `xml:"country,omitempty" json:"countries,omitempty" db:"countries,omitempty"` - EpisodeNums []EpisodeNum `xml:"episode-num,omitempty" json:"episodeNums,omitempty" db:"episode_nums,omitempty"` + EpisodeNums []EpisodeNum `xml:"episode-num,omitempty" json:"episodeNums,omitempty" db:"episode_nums,omitempty"` Video *Video `xml:"video,omitempty" json:"video,omitempty" db:"video,omitempty"` Audio *Audio `xml:"audio,omitempty" json:"audio,omitempty" db:"audio,omitempty"` - PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previouslyShown,omitempty" db:"previously_shown,omitempty"` + PreviouslyShown *PreviouslyShown `xml:"previously-shown,omitempty" json:"previouslyShown,omitempty" db:"previously_shown,omitempty"` Premiere *CommonElement `xml:"premiere,omitempty" json:"premiere,omitempty" db:"premiere,omitempty"` - LastChance *CommonElement `xml:"last-chance,omitempty" json:"lastChance,omitempty" db:"last_chance,omitempty"` + LastChance *CommonElement `xml:"last-chance,omitempty" json:"lastChance,omitempty" db:"last_chance,omitempty"` New *ElementPresent `xml:"new" json:"new,omitempty" db:"new,omitempty"` Subtitles []Subtitle `xml:"subtitles,omitempty" json:"subtitles,omitempty" db:"subtitles,omitempty"` Ratings []Rating `xml:"rating,omitempty" json:"ratings,omitempty" db:"ratings,omitempty"` - StarRatings []Rating `xml:"star-rating,omitempty" json:"starRatings,omitempty" db:"star_ratings,omitempty"` + StarRatings []Rating `xml:"star-rating,omitempty" json:"starRatings,omitempty" db:"star_ratings,omitempty"` Reviews []Review `xml:"review,omitempty" json:"reviews,omitempty" db:"reviews,omitempty"` Start *Time `xml:"start,attr" json:"start" db:"start"` Stop *Time `xml:"stop,attr,omitempty" json:"stop,omitempty" db:"stop,omitempty"` - PDCStart *Time `xml:"pdc-start,attr,omitempty" json:"pdcStart,omitempty" db:"pdc_start,omitempty"` - VPSStart *Time `xml:"vps-start,attr,omitempty" json:"vpsStart,omitempty" db:"vps_start,omitempty"` + PDCStart *Time `xml:"pdc-start,attr,omitempty" json:"pdcStart,omitempty" db:"pdc_start,omitempty"` + VPSStart *Time `xml:"vps-start,attr,omitempty" json:"vpsStart,omitempty" db:"vps_start,omitempty"` Showview string `xml:"showview,attr,omitempty" json:"showview,omitempty" db:"showview,omitempty"` Videoplus string `xml:"videoplus,attr,omitempty" json:"videoplus,omitempty" db:"videoplus,omitempty"` Channel string `xml:"channel,attr" json:"channel" db:"channel"` diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql index 0dcf335..cd95373 100644 --- a/migrations/00001_init.sql +++ b/migrations/00001_init.sql @@ -39,13 +39,23 @@ CREATE TABLE IF NOT EXISTS guide_source_channel ( id INTEGER PRIMARY KEY AUTOINCREMENT, guide_id INTEGER, xmltv_id TEXT, - display_names TEXT, - urls TEXT, - icons TEXT, - channel_number TEXT, - hd BOOLEAN, + data TEXT, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + + CONSTRAINT channel_unique UNIQUE (guide_id, xmltv_id), + FOREIGN KEY(guide_id) REFERENCES guide_source(id) +); + +CREATE TABLE IF NOT EXISTS guide_source_programme ( + guide_id INT, + channel TEXT, + start TIMESTAMP, + end TIMESTAMP, + date DATE, + data TEXT, imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, + CONSTRAINT programme_unique UNIQUE (guide_id, channel, start, end), FOREIGN KEY(guide_id) REFERENCES guide_source(id) ); diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index 6bbe693..156fdbc 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -6,6 +6,7 @@ import ( "time" "github.com/jmoiron/sqlx" + "github.com/tellytv/telly/internal/xmltv" ) // GuideSourceChannelDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -30,23 +31,20 @@ func (db *GuideSourceChannelDB) tableName() string { } type GuideSourceChannel struct { - ID int `db:"id"` - GuideID int `db:"guide_id"` - XMLTVID string `db:"xmltv_id"` - DisplayNames json.RawMessage `db:"display_names"` - URLs json.RawMessage `db:"urls"` - Icons json.RawMessage `db:"icons"` - ChannelNumber string `db:"channel_number"` - HighDefinition bool `db:"hd" json:"HD"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + GuideID int `db:"guide_id"` + XMLTVID string `db:"xmltv_id"` + Data json.RawMessage `db:"data"` + ImportedAt *time.Time `db:"imported_at"` GuideSource *GuideSource GuideSourceName string + XMLTV *xmltv.Channel `json:"-"` } // GuideSourceChannelAPI contains all methods for the User struct type GuideSourceChannelAPI interface { - InsertGuideSourceChannel(channelStruct GuideSourceChannel) (*GuideSourceChannel, error) + InsertGuideSourceChannel(guideID int, channel xmltv.Channel) (*GuideSourceChannel, error) DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) @@ -58,29 +56,41 @@ SELECT G.id, G.guide_id, G.xmltv_id, - G.display_names, - G.urls, - G.icons, - G.channel_number, - G.hd, + G.data, G.imported_at FROM guide_source_channel G` // InsertGuideSourceChannel inserts a new GuideSourceChannel into the database. -func (db *GuideSourceChannelDB) InsertGuideSourceChannel(channelStruct GuideSourceChannel) (*GuideSourceChannel, error) { - channel := GuideSourceChannel{} +func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel xmltv.Channel) (*GuideSourceChannel, error) { + marshalled, marshalErr := json.Marshal(channel) + if marshalErr != nil { + return nil, marshalErr + } + + insertingChannel := GuideSourceChannel{ + GuideID: guideID, + XMLTVID: channel.ID, + Data: marshalled, + } + res, err := db.SQL.NamedExec(` - INSERT INTO guide_source_channel (guide_id, xmltv_id, display_names, urls, icons, channel_number, hd) - VALUES (:guide_id, :xmltv_id, :display_names, :urls, :icons, :channel_number, :hd)`, channelStruct) + INSERT INTO guide_source_channel (guide_id, xmltv_id, data) + VALUES (:guide_id, :xmltv_id, :data)`, insertingChannel) if err != nil { - return &channel, err + return nil, err } rowID, rowIDErr := res.LastInsertId() if rowIDErr != nil { - return &channel, rowIDErr + return nil, rowIDErr } - err = db.SQL.Get(&channel, "SELECT * FROM guide_source_channel WHERE id = $1", rowID) - return &channel, err + outputChannel := GuideSourceChannel{} + if getErr := db.SQL.Get(&outputChannel, "SELECT * FROM guide_source_channel WHERE id = $1", rowID); getErr != nil { + return nil, getErr + } + if unmarshalErr := json.Unmarshal(outputChannel.Data, &outputChannel.XMLTV); unmarshalErr != nil { + return nil, unmarshalErr + } + return &outputChannel, err } // GetGuideSourceChannelByID returns a single GuideSourceChannel for the given ID. diff --git a/models/guide_source_programme.go b/models/guide_source_programme.go new file mode 100644 index 0000000..0a8b4e2 --- /dev/null +++ b/models/guide_source_programme.go @@ -0,0 +1,174 @@ +package models + +import ( + "encoding/json" + "fmt" + "time" + + "github.com/jmoiron/sqlx" + "github.com/tellytv/telly/internal/xmltv" +) + +// GuideSourceProgrammeDB is a struct containing initialized the SQL connection as well as the APICollection. +// Why is it spelled like this instead of "program"? Matches XMLTV spec which this code is based on. +type GuideSourceProgrammeDB struct { + SQL *sqlx.DB + Collection *APICollection +} + +func newGuideSourceProgrammeDB( + SQL *sqlx.DB, + Collection *APICollection, +) *GuideSourceProgrammeDB { + db := &GuideSourceProgrammeDB{ + SQL: SQL, + Collection: Collection, + } + return db +} + +func (db *GuideSourceProgrammeDB) tableName() string { + return "guide_source_programme" +} + +type GuideSourceProgramme struct { + GuideID int `db:"guide_id"` + Channel string `db:"channel"` + StartTime *time.Time `db:"start"` + EndTime *time.Time `db:"end"` + Date *time.Time `db:"date,omitempty"` + Data json.RawMessage `db:"data"` + ImportedAt *time.Time `db:"imported_at"` + + XMLTV *xmltv.Programme `json:"-"` +} + +// GuideSourceProgrammeAPI contains all methods for the User struct +type GuideSourceProgrammeAPI interface { + InsertGuideSourceProgramme(guideID int, programme xmltv.Programme) (*GuideSourceProgramme, error) + DeleteGuideSourceProgramme(channelID int) (*GuideSourceProgramme, error) + UpdateGuideSourceProgramme(channelID int, description string) (*GuideSourceProgramme, error) + GetGuideSourceProgrammeByID(id int) (*GuideSourceProgramme, error) + GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) + GetProgrammesForChannel(channelID string) ([]GuideSourceProgramme, error) + GetProgrammesForGuideID(guideSourceID int) ([]GuideSourceProgramme, error) +} + +const baseGuideSourceProgrammeQuery string = ` +SELECT + G.guide_id, + G.channel, + G.start, + G.end, + G.date, + G.data, + G.imported_at + FROM guide_source_programme G` + +// InsertGuideSourceProgramme inserts a new GuideSourceProgramme into the database. +func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, programme xmltv.Programme) (*GuideSourceProgramme, error) { + marshalled, marshalErr := json.Marshal(programme) + if marshalErr != nil { + return nil, marshalErr + } + date := time.Time(programme.Date) + insertingProgramme := GuideSourceProgramme{ + GuideID: guideID, + Channel: programme.Channel, + StartTime: &programme.Start.Time, + EndTime: &programme.Stop.Time, + Date: &date, + Data: marshalled, + } + + res, err := db.SQL.NamedExec(` + INSERT INTO guide_source_programme (guide_id, channel, start, end, date, data) + VALUES (:guide_id, :channel, :start, :end, :date, :data)`, insertingProgramme) + if err != nil { + return nil, err + } + rowID, rowIDErr := res.LastInsertId() + if rowIDErr != nil { + return nil, rowIDErr + } + outputProgramme := GuideSourceProgramme{} + if getErr := db.SQL.Get(&outputProgramme, "SELECT * FROM guide_source_programme WHERE rowid = $1", rowID); getErr != nil { + return nil, getErr + } + if unmarshalErr := json.Unmarshal(outputProgramme.Data, &outputProgramme.XMLTV); unmarshalErr != nil { + return nil, unmarshalErr + } + return &outputProgramme, err +} + +// GetGuideSourceProgrammeByID returns a single GuideSourceProgramme for the given ID. +func (db *GuideSourceProgrammeDB) GetGuideSourceProgrammeByID(id int) (*GuideSourceProgramme, error) { + var programme GuideSourceProgramme + err := db.SQL.Get(&programme, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceProgrammeQuery), id) + if err != nil { + return nil, err + } + return &programme, err +} + +// DeleteGuideSourceProgramme marks a programme with the given ID as deleted. +func (db *GuideSourceProgrammeDB) DeleteGuideSourceProgramme(programmeID int) (*GuideSourceProgramme, error) { + programme := GuideSourceProgramme{} + err := db.SQL.Get(&programme, `DELETE FROM guide_source_programme WHERE id = $1`, programmeID) + return &programme, err +} + +// UpdateGuideSourceProgramme updates a programme. +func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID int, description string) (*GuideSourceProgramme, error) { + programme := GuideSourceProgramme{} + err := db.SQL.Get(&programme, `UPDATE guide_source_programme SET description = $2 WHERE id = $1 RETURNING *`, programmeID, description) + return &programme, err +} + +// GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. +func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { + programmes := make([]GuideSourceProgramme, 0) + err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.channel = (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) AND G.start >= datetime('now')`, baseGuideSourceProgrammeQuery)) + if err != nil { + return nil, err + } + for idx, programme := range programmes { + if unmarshalErr := json.Unmarshal(programme.Data, &programme.XMLTV); unmarshalErr != nil { + return nil, unmarshalErr + } + programmes[idx] = programme + } + return programmes, err +} + +// GetProgrammesForChannel returns a slice of GuideSourceProgrammes for the given XMLTV channel ID. +func (db *GuideSourceProgrammeDB) GetProgrammesForChannel(channelID string) ([]GuideSourceProgramme, error) { + programmes := make([]GuideSourceProgramme, 0) + err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.channel = $1 AND G.start >= datetime('now') AND G.start <= datetime('now', '+6 hours')`, baseGuideSourceProgrammeQuery), channelID) + if err != nil { + return nil, err + } + for idx, programme := range programmes { + if unmarshalErr := json.Unmarshal(programme.Data, &programme.XMLTV); unmarshalErr != nil { + return nil, unmarshalErr + } + programmes[idx] = programme + } + return programmes, err +} + +// GetProgrammesForGuideID returns a slice of GuideSourceProgrammes for the given guide ID. +func (db *GuideSourceProgrammeDB) GetProgrammesForGuideID(guideSourceID int) ([]GuideSourceProgramme, error) { + programmes := make([]GuideSourceProgramme, 0) + err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.guide_id = $1 AND G.start >= datetime('now') AND G.start <= datetime('now', '+6 hours')`, baseGuideSourceProgrammeQuery), guideSourceID) + if err != nil { + return nil, err + } + for idx, programme := range programmes { + if unmarshalErr := json.Unmarshal(programme.Data, &programme.XMLTV); unmarshalErr != nil { + return nil, unmarshalErr + } + programmes[idx] = programme + } + return programmes, err +} diff --git a/models/main.go b/models/main.go index e7ae5f5..26136f4 100644 --- a/models/main.go +++ b/models/main.go @@ -41,12 +41,13 @@ var ( // APICollection is a struct containing all models. type APICollection struct { - GuideSource GuideSourceAPI - GuideSourceChannel GuideSourceChannelAPI - Lineup LineupAPI - LineupChannel LineupChannelAPI - VideoSource VideoSourceAPI - VideoSourceTrack VideoSourceTrackAPI + GuideSource GuideSourceAPI + GuideSourceChannel GuideSourceChannelAPI + GuideSourceProgramme GuideSourceProgrammeAPI + Lineup LineupAPI + LineupChannel LineupChannelAPI + VideoSource VideoSourceAPI + VideoSourceTrack VideoSourceTrackAPI } // NewAPICollection returns an initialized APICollection struct. @@ -55,6 +56,7 @@ func NewAPICollection(ctx context.Context, db *sqlx.DB) *APICollection { api.GuideSource = newGuideSourceDB(db, api) api.GuideSourceChannel = newGuideSourceChannelDB(db, api) + api.GuideSourceProgramme = newGuideSourceProgrammeDB(db, api) api.Lineup = newLineupDB(db, api) api.LineupChannel = newLineupChannelDB(db, api) api.VideoSource = newVideoSourceDB(db, api) diff --git a/models/old_lineup.go b/models/old_lineup.go index b75bd7e..cecd9d1 100644 --- a/models/old_lineup.go +++ b/models/old_lineup.go @@ -246,8 +246,8 @@ func (l *Lineup) processProviderChannel(channel *providers.ProviderChannel, prog l.assignedChannelNumber = l.assignedChannelNumber + 1 } - if channel.EPGChannel != nil && channel.EPGChannel.LCN == 0 { - channel.EPGChannel.LCN = channel.Number + if channel.EPGChannel != nil && channel.EPGChannel.LCN == "" { + channel.EPGChannel.LCN = strconv.Itoa(channel.Number) } if channel.Logo != "" && channel.EPGChannel != nil && !containsIcon(channel.EPGChannel.Icons, channel.Logo) { From d89f114c2f90bbc076f84d6e766e6199684c21e8 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Fri, 24 Aug 2018 23:51:25 -0700 Subject: [PATCH 057/182] Update packr --- api/a_api-packr.go | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index 8cbfcfb..6aa38ba 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -7,12 +7,12 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5SRQXLzIAyF9zkFv9a/w7SrLsC9RC+gYDlWKoMHFCe+fQfTNjNdtSvQJ96T3uD+DSnotpCZdJb+4OphBOPZA0WogHDoD8a4mRRNmDAXUg9XHbsX2BvKKtS/kcjmbCsqPmEhM2UaPVh4OEScycPKdFtSVjAhRaWoHm486OQHWjlQtxf/DUdWRulKQCH/1GyE47vJJB44pAimru+BZzyTvXeNtbkjrrU8ckivq3+ucR7ioptQmYj063kjx1AK9M624O6Uhm0fi8vS5ZS0d/b7enAlZF70cwelu9oLrtgomJKDh3yNyjMdL7tta/W/ES5JtpFFyt+lM3L8obItibPtpz8CAAD//9U7Pon6AQAA\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"H4sIAAAAAAAA/+y9CXfbNrY4/lUoTn8K8QwrcreZkYJqEidp3CZ2GjvdVD0/WoQk1hSggqAdx9L/s/8PVgIkJNttZ95y5pw2FkmsFxcXd0dynZOMXveu8cUqnV5+U1KyQoF36/V4Anqrqlwk4/FnE3gbf/r5r+/jwawiU55TkmDIIQG3cVXiqOQsn/J4yHuYMcpOLn7FU45u8eB2s9nAz1qVcA9/WFHGS0SS+ON7chGDDYz//vTrZ3d0cJWyiIlK1198dxKDoSkc0QSDW4Z5xUiERwcIIdwrMJnzxQiP+5O6VV4X6zGcVVOcuD3arzzBYAM52AxYj1C62vDeKl9hZAuD2xlliRgQRuMJ5Kg/5E9SNq+WmPBSdz7ke3sAj/kE2S9jPhnqPqjqQzb8ktHlU8bSG0Q38OUPs4P7AIIv8rLbFf/2zs/xB45JVq7XzhDV8NR69ErM3zLKKb9Z4ZPZen17fr4Sz+fng/Fkk5OSp2SK6SyS4+h2fbjgni2O+MbpRX41sCBRTiIOeG+RlifX5C2jK8z4TUJAt5vgMZkgPiYTsDEgqNdFTNEuJ0vArZzWlJKSs2rKKUN8g2UxATEzD0SqokAIkZGe5JThlOOEgEHC3GL1b0jwdcTAZpMASAUurcrFNzGAufj9dX5axQAWEjGfPX4VA1jJMo8fP48BlAhLPqvE71T8fnO5/CEGcFrjBXamwcV4IVPrQBHuTdOiSMTEwHot/gzL65xPFwntlTdk+kJsnu/TolLTgs7bswWj1wR1Dlov04sCq/d5ecrpaoUz8djERHA7TUsc9Qe0l+GS5yQVI0R5Dy9X/GZ4wXB6OZRFDgb5LOlwcLuj5CafJTGVEI8RElCls4iD23yWLBIO1IQLxMdVj304rS7KKcsvMJskYBgcfxF4Cf3+C1j00ixLKNjgosRRGA79Ri2x1quEQg70wDM8S6uCDx5YXS7jxuxb84MlHGIPH5sTdumFoSyLvBS7XmGqgzguqoiOuX5lycW2ld+4I+gR/IF76Cg3kkUOhXi9c1HM0B9bV5LvnZUT/4UAmWpPVk0waLQ4pctVgblHOO/dpqmcNFutSGlg3Gp4WtByS6s43ISzLRv9nIeB6aBILwjH8y2AdCsagKm5OsNJmo1thaHbXA2ruxt0vj0l2Ts8vZkWXuvq3FCLsEoZJhxy77EcOthsXiqq5RVzXnkDgs5SCRxurtWB1wzCjVY51LtokxQ9vd1WYuxgyHv19kNTeVCudlJnWKj5VrAMUmjTq9Msl82mqKy3Zl6+NH0QMKoQGZBuN6mQQhDIkF5wcbTYtYKkgwxh7XaTFDUPMeg1nLowBN1uKQmi97Z3kZMsSQGA3mtUtguVAAAoNxnhAstTqKkCqqDZz4hBZxuiApbbSV+b8MhzxFtYw6yIogrqPlrVMB7Ks3+Wz3tViZ/jFcPTlOPs9IZMF4wSWpWSEL5KSVbkZN7t8gB1HGnWiLObE3aKufyacFgPAgo4ttFz4FZ8L74kXp3NXWSzPfXd04UEPWzCw3yWOIQXkC0QSHaCQKFkkAaBQbINCLtqDeXhLAYXGA0gI/e9YnUwbBYlqNMHg7S3oCV/h4Wg8GI7rZQd3hpo+ESGAC7ai/Aw1Nhmc/dRVRPC4UOXtF4h07AqTwI8gUPkFQXCdl+CzZ+zFbYhArn34odLKm4scOQ0zhynJeTLDpzd3DqE185cSF/TVLDHakMFFvhhkLkDG0LjNYBCTWlMYMPv6l1wdqrP+CLNIjHtGAwFDHgIBsTAoBZNH9btKMHNHcchDuw4KDZd0gYNB+KLpvudg+2sxG4GwtkY3gzbTINz0MpvuMXLbJKpI/svXNk/cuTY6Xodt3dCnJMId7stVn2zgV+/+Xl1l4YjL7V6wyX3uncx3A7C3W5LNsKi9fy0uqd6Q4uYtBYxh1yxCehWMU2DTh+Kw2jgDmMDJWkeNE4i9vt2CQ3tEmjo1MBZbUFJXz/7sfi3zuJforPYws0SBTvmcrGQjIjWAOzFkcSOMqLTacUYzqKsYjmZR3Z7SRZ68AuJoniP9JbpaotubO9gLwZRvId7nJ5y0UYCNqD3K81JEsvqYBDHhoM2HKNik0pEIOuRdIlR/N7rWOJYDIMrnzAXggCyJh+6SWR1sU8CrSK6gW8Ov7y+B4KqTSeVnQ6NyRN1Ttm5pKtVcaNAbFUtznFl5QJHIdoTvI73ZrPhPc5uDkWtED1hCMN8s4GCBNxFlxp71WuuxPwsX2Ja8cQTIeU+34ij77uDl6f3pE0/Xv/22NCmj7NvV0Z1JtW3WnWm6FcNvkpTIrxeJxgVhh69ZXSZl3i91j8A7OD2MUlopL9H+XJVRDNakSy2ahG84b2TixKzK6kQcRW0pntsBfDzvDydpkXKhIiJu1192tZnGLZaHldZUOQzh+Bzw8iJQWIzDtIracWm6tSDpCeoSCppACQbT/UQODE1xJXyR47JVIc5YmKb2YNKlxXsJR1RtdVzdYCqAYBBLgVD59V6XTyQh+zk2+Wp+jDOjaTE2c2p8xbAh/YX6q7bTUKvxdI13xOg8SZvMDtmdXJ/CbwB+3qaepc3Z4sdXuyh80uCLFebNQNQi5MJF/vSHfOMshepRyigxUSX0BJ8nXBUJRyAxDmrjG5xSBGpUTBxsVpy4onLdkuhi3a7tMXcM8GegwZUQ5jtSUkKHa3ySMoqLnzd5sa0R+2+3q5JdQfwp5to+q4lSfQ3yH1zTYKBUhf5A+FUk6wtgHDXCiNBHoF71pqjfMhDK+UdEBsYYkQlLANyZsLEosnBNvXP9fkuyZpAA4g3gt9WJP+ex8PLH2YH5njQVhPHsjLkHi0LiVX6pHAZeebo9ICZiiCAAkc8Jt5+bX5Iarq+XvP1mowkS9Vr0dVB671W0AmknzKSDRpcpDlkXPjrxe8xXNLiCiegxxeYJA0ulyPnlDtMCaE8muUki5Y0qwocPYr38F78SEBN0jbem9IMo/jNyfP3r1+cH5+cnb88eX/8PIZ8Azakd4lvyvY2GU82kJiRIAId4yskvTxDsZhVvIHLi6Ozu6UfZaSU/5onl7GuUa3bjUm1vMDMkYL0TtpsoOAQ7oNRnYMh16QW3WqwDq5onkV9WGIe3Yv8ymGJrTK/d416iwnhRmHyXcBxEQ7FpnA9/dOb5QUtut2tnwSJH9U/k9htUfDU//iH9wby3iefeL36g9jAVbn45u41NRrmAA8aGKuQZa+/+O7krnYJpSvkSYlQ2VTvSUkEPhpKIiRzQ0m0vVYymoKpNzZaxbMrG62QRl0GNHUxc6fhHwtsm6Y84S4FKkNSxUj7O5QDQSvHE7DhnjHiDl60Yf24lxHl3B2E/lCzsa4yBoONpDHDADu7S2kDudhzVtmpBumyGdYiNPUtQnCFWqOACxQY9tCbfv+PTX9ozvgM7R/AGZqOpprKDPpDMgSC9C3pFVanNCRoby97Mut2p+Nssl7LFvJZkrt2lhXodgsrmCUr4FiFEEKVK8IJ2EtODgnZpvLlvbsxKG1W0RgFBuPGhwkAkBmKmywAEPPWc14YXkbObahWa44W42wixQSrtErm/tTmnkVJTXPemiO4rac4nsgNeoUawxte3T1ZjOzmSpMrM1MwwMrP6ApsNvks4Y4EGGxHKWtdfE6zzONjJPau11wyby/evD37yfIF6lHq5hGSyAkcbnKo0dz4ZdSeDdO0xDUtHGjZL+FAOk0Yfd8gnyXEWqDr8h1DO4kHcMNvWVOB3m1WomyYM0S5YKPnaZa9lbvF6IDIMNFjBM1dM2aTjfL3MM4QLZG7IgxP6ZzkH3EWcZyyjF6TKN7je3GUZpl4SSOX1PViw18lgY1qjPHNgUyAdjEjALqTMHvVX2W1j7dJFg0SIxHJUK1eTjL84UTwlsP9gw5Cylq2KvIpTgg8aOJTPZKtvWkaSBpWcSHRdBDCIzLaP0AIEafrbpeo2WIjNRsCN8aTgW/vFuORmIqShJt1dCgm0Kz5x/fkYvdxSnpClNSnaujES9j/RGUrkNU2nodfg90OqFvxRrLxwF1No27lDXUrB4PEUbEi3lC3EnWA5m2OOskNxNKyzOfE53/NTAVyHECGWgInecKGZG8PmIJUgsQRP8kE6PZrlPTBpQ8kSBXUqIAanTgqMbBFQVnDs6gxegeriseaHc25UkdNIEF9K7+PtM0Kg8Gtb41w5QDylZWhxXCRYt8BvL1KiwoPpDGG7O1NYEYJHnTwZrPZuKrDWs3xoJFKJobU8qJW7wom0owaFmg8kcY3sRjDRI1MIMt6zff3o6/6oNvtJAzlys8HgJ4Y4xAUaieznpyCozCh6FbZYPBmM8tJWhQ3SqXU7XaYrNztJgTlPTUsSRSUCg/Y8uLI1oegVhdvjPBa1IApH6LfqE/eKnH1HMDBmRCzHGT/RY9Twbeu/phINv2dItl0s2lY/+5ScCv+8HeYzlYPtJktdtjI4OyPis31rOf3tDpKXg3eaF/suv7St2dc3dOecSNtGDfO9rxwvl4hDJeyy/N/26gcGxVt2Kjg9f9xyZA1JEMakAzzf51kWAgpqUJsxO6SDIsnVbfLxoUjGaaJOGQvEtqQAm98ye/Gl/bOR4fiVS3N3SgJbpbkSnLTY8prya14UmnJrUT5uJDH1zwpZedlQE5TowjIZlN008PDqT8c5wQ4TKYt2Wvalr3O/y1n/VvO+recJeSs+tw8/IN6xPO2zlDM9sO/Rl18ep8wFZjvCFRpmlcVBW5ZY0Mm2tp0e79AldyLxMiCISrBMjuCUxKKOHCW43Srhxjtdun4w6SOZPkwScAwOKdg8EoeDF7JtbtkGDb9Ri1JKJK8HbzywOpe8Ere5Eocg+uHf8er/Dte5d/xKv/UeJVrAF/sjkehaj45LEKEuNgaj1KhwswyTQgY5ToIJW8HodBmEErW7SZpklStCBTQiDlRdKxqh5NUAEDvNSrahQogXYOs728lHiTO5uKXiTkpHByisNhOsf7kmJN7Svv/B4JN7jnT//tRJos/ElWy+N8URfLHkPv/ZPjI79LuPTxO5GHd/PEAkXv298DIkMX/zEiQUwDPdklPWj6qPQnX6/gf/6gf41q4O0rAba3ZvPwz/AdPBMbYJk/+eVkqjqQc+fZ/v/sza7g/03v6CJ42HAM/OL6AH7a4/526Pn+nSQY2jnM1GzG136jvXE3bztX3Jq2dkEzU8qqmQa9qCu5NsLrdUD/dbrI9ecQWd+pmYgor2/3J7tT3nti/3I/66f9+P+qz/zHO0yd/irv00//J7tL1cfLUC3pZ/VnRLrb944bZMGCq7ZXTBc6qQhkCn//eLDVWoaPFWw5pj1YcGx2geTwiGf6AGKRKG4v6kO6Q3bYoK1QfPUJ5Prs5xh+UltrpD2rpuu5Si+Pi594e1Ph1H/2G15d2LlP1/4CWw2v00Kg5drQqmZh3oQAwF9usBw3qQ2b31ZA8Yd1uh2vdhHQs4VrJMyYTMORWwcQdnctmA7+/q0PLCPi+6wJ2jtLKKJSg2zwIbjNudUgb7RAvuboFgHyzgW/aROputs44e4waz4P4H/8wv+NNAuCv9wcvHr+ZJGA4tCYe7fshmQLpwiEhYCdba501MIxXCDRwAqrE1kkR7Q0iyLhgLhxA1J/MrwRsFMBe3zUlM52ziRp80KRVK3dqUnR2s8KaHL1l9CrPcBYphXqUUVxGhPJoShnDU17cSDKFBe2PWrx2Tbfco1KeyO9Do9/l/eBSuE7t4VDT21fb6GHHoYdmEFvopcBKSStfNjUsHrP5FuzaL5bLHtntYTBCusl4O2WAfchI7jU8uvGZ5WlfJ1gu6XtxFOp37/S7V8677/W7bS2+sS3+KkqqE3eeYDCKUxLl5CotcrP28SA2ESnDIK78RKtoZfBFGTGvF5jhKI1KznC6jK7TMsIfVnjKcdaLRPlpSkydKCVRHcgJzTEIlbshjCiLjsSWvihwL3Zd2T4qrt23RjxvWCNeJhwkVJnbnm07CBs+NQh3uzjsGqNOxl2aSXt+NQQYpeEN6+V545BxDqam1mObej7UwGHrqAop+J3TQZ1JNYS/9qRO24oSxkIbLUxMDPiiXNGQ1DbVi54yHN3QKioovczJPJpRFv3XMl2d0QT818glJEIaTUTLv8lRgY1c09+2ib4WWitGZeIGzT6If56yOeIhiVewQEFv2chlMcUgftAcg2neaxxophD+8FDWC/I286XHL9itKa0IF/yVnQZbr+kD2S3lBSQ1S8idgqNm0q0blkt2u7fXdgxTdG0rTu7Adh/RfvZgLeD7NuEjF+H0mYyvo2tIa1dUpqRyy/C6ZyjtOHJIYkxgY7q3NwGwdiNhjmBvWgEADLydAQBkm8E7aTi0o/5OjVoZpQ02eefFCA/UZF6KmoIia689WWvLSRg+AjYOeQ9i6B1Quw/ENDoqzkEVpA7e37bcJ3c1ZjeuMT3KXdHytrxXEzUDucXN8l6teOu5Ef+rZX0tl1UCs3mQ/rMgvZ3J3lXLwhL+jvm2uPOHAt6A63sfXC4v8rN9+wDcfiNxe72OS+mv6XwKr4LYbwEJ2jAJgrcQp8wFlse5c4RsWzZI/YWjTW6cBUfOLI/OXB6d7oKrljJ2FpL+656fJYaKXqv9yYxgghFVDCbkiEoJJUygXYo8ctFikNQY1SSAZn/QzeDXesE3oQM+qdkms3LrNQZ7sTnwXcmgJp+fGM2uO9Y+ku5jCUHHUiDovT05PTo7+v7F+dHxy6Pjo7OfAAyshbOqrNb7SN1W8kkNXHno6q/fJVg+A1Xqa1ezRB1VO4FY8m5yAxEANoOkJaxwOWIOYEAw4DXn8q1UWgHtmf7tLtalDkmQDqfbgRHicaaUSDdqwv8om/NTkM2p27eczk93cTpmPqzbTdj2+QwfzhLZuTJIe4u0NGxvplTcF9VshhkaT8Smm/L8CksG6g+oqlQrTxqgGFnl/bHaUkqbr7o3nokNZZIu3GbPjOejVm4FuDWJSr+LIVPD1xqz3nlOCGan1YWYvmjSH6H52jLHqKayLPmoVkm9vre2zF+nPuxrd2E9um7XvtAANNqA3fLLP0cSCwpSjlpeDVGZNbVzuaGoajr7+5DrGXzVH9VuHuIEWAjqAMCgBYEWnO6a/CZ55vDU37hHb011f2xii1TXywCt7UTmk+Qb6Fo0Mf5DhgKlodrWHdRmX8GJGv59/8CaF44TCkYJQ7i3oqsEQFPkq4OQFsltQRJpXQ2AQasw9QpAHUDIul3XZNvt4nF/4jP54/5k8GNCQCL4HwZ0oAXerm7QKjqHyGnP1chREmfNMBWiY1OUs9Z7p+TO+BTix6eQrfEpZOuIHTPtdjsBE2eHpMscsvocYTKqpvaha8XH3O0w2Qo+8dzy+kPH2UAPAXKEtUISs9J605gBKpeDbrffQYjbhe1g132sg5uxLtbZ3LRlctNs83o3nn9sO2BDuNA88Ijn38tDK3gKIL0D3/iOpeM1rORmdl0eG/6OgiIpzZR8kvygzranoPpQR2OZeAcnAfON73+A3ew5OdagErWcWRjvAwz5He7GjZiQmq/lOOStZcN7tZ+CAZc4qDUCQYZ4r5TLD6SOgj4hQ7q3B9iYTsIOuEGnvq3DMgeCBn/f6JzqFcAtD9X+8A+P3HAPQ7++rov6dzvC3Tmp4IBxc8DcEmEoNowZMEP9IXvCh2xvD5Axm7g2mnsNeZebdtvduxGmVm8cgf5t/i7gH8F3QyTAsHsNeZSi0WHYg+AevXm4NUqsF0UDwwC81hFfAx88oorj221LJY0V0HywCrXXm7jljZ+W4cyOCiukHF9DyfU/wuGIBV91kysRSxLntwDmf/TU84kzMwMiO0+6sFYWNRk8GfEkC5u/96Ahu5qSpQOMZNiOsNur1Wtd2kxM+Qew6VtQ1kVLBdCR89vzehloZJMLSrHDAhc4aVsv3EguK5lXWOo4JONW3ZVNdEoJwVMusRPfU752wmWd6kPSO2d4dqj068NaiVhiKd9BilyJvDZrsdoUz0yDMvjHPCRSdaNk8/KBGN5iQJg35d2IfQ+HUBcAyquvBVYZhmu4Fgsiycc9QX3glpfTFsWNc7hTAfH9A8i/OtheIbAwOSXS0+K8fh6G6sMOW69Jt8sE77des6aPV+3i3KhofD/SP8xva9IHLev9Mp1yym4ky11DoS+ecitI3sWF32NLzjE/VT0moOGC5rZUF9vmG6zHPax1xC4X7ka2KsnC4eL1XAWme4WaJEzCflv/zhrXnqK6Ux9iSbuKUhuDpmdoQ4e2UsecBzPFuAIhvaqNPErajUvfZ+QfuG4BDNSB58bw6hVvs9mCFlomWxx8Tt6bKUa3hnUe6PQsClEtDpnXfXjNcrlHB53+BhqYu7UaJeoB7yhkIWbKpC4abqCzFm6J+q3fXg1qp3T9cgP1oJyv+s0GNmec1mDdbODqX0pLG2e7MWmf+/EMuFVlF4u4VSXnjMvHfRPnuKNXPwAlIMv9M44FZ+9ij9rhmmDoAILWvpLMUCv0ZJMwl39YYF9MpY4eLcM1Tbw17i9HZCDBoh9UOgk4U4RqgHv6F1SYpdRviumYbWU6rCPDeYbLqRHxyPwN5mmW8vRY6oSOyK9qemf0EpPYFFKvBeye45nOwNRBiI8ynLij5t6oY0Ypj+24uRn3BpgxB5gek28l4M/nDy6K9+r5aBZljlF8fr5KWbrEHLPy/NwJ0LjCfqRA4FByYWfl3bHKWkXaaknpLjkmEy/7lkY6s4WV/49JcJRwAIZe6i4mmYoxnSAhJW82m4R7N5M6ClL4u8Yimne9CSioDcu1bxJXZ8lQJS0j+DpJMKJABl7qchiWyVhNZAI5qJM/FT1pKtU3PcLCSxOmIG7mICDSyN02x2CEx3M8GWi9Y4ZnOcH2O4ZzbJJ9jScbIIoOjSL/CSJDoM0iYpOYMSVMgEL841xFm4uDzuAckQENdQK3Ruiqo+oEkLoSl79jMKTO7A+LElFI5Va8USLmDCfxU5IWNx/xS8peEM6kHYASsUQxGJq8oRLyYgtWRAEgqx2i1A273a76Cy/CpUpczLrd0JcfKLvE7OuCXqTF6ZSucLcrCrtYsaUIPA/3NZcFu131d71e4vX6AsNrjJrJq/sAHmqKa9HiA9ba2ENsSPc57in/T+1viK0zLjjEqH5S7Hm9OfWyzTF3cEqsTJm8SVeewlruG16nzKlDhsROiTHhLMdl3JG6+rjMP2L922tozCYIIe9VT1ftdpNDjBiwOHboEPpTSegdWFp7wc+U4NF104cD3Drug5L+S/zegIEo39PWQmtqf5NPGT1Ly8sk9l7xtLyMPaPLC+xnGlH56tomj4AZhHe7eXmcHss0KeoXd1o+w1pLtN0FQx3JUTMbpP4cj+M9LLNynWGTbAtGMdiLJ7HxekLINBbHe6q5Hr3CjOVZholYeedz44sqTRplxLPlBup0X3WHvC7Nh00lfvwLsb4hKpnMiA+UtK0a6kPiwOgIe5qD8/MZZdcpywTfcX6OjjDcdQQKEAsynSiDuW31Eu9OuicwqUF240bXMRCFmuNB6AiPcAIGKgbkBKMrnOiDOA546d9ycTQP8GYD4FtV+ETm+kmLGMCn6s0pLmYxgMf66TJf6TfP5fGtpJ8YvlMEVO1w+D1G7zB8UxPVo+NvXhyenbyLAfx1G9cDbkMsxhxz1PIFanhKvBM8NELib8tF6LgqCgUCyuSrQXRMjR8yk76n8Z7cDHtxp3Yc4ppJeX2f0e7SPnp5ABMMZDTid2pbD8xvw4mxUrDYKquFwnXFTsqwpLNX705+OD96Wd8GIICMe8fvX7+WgP5VPDX5vwbTF6fkpubyAt5pPHmDgcAIOf33QXUA3sBX0gL8EqP3GH7EAeRX83ZCQYt8qkUFJ+sgfIbR7QZ+3ZCwzIkheC4MZJAnF5T8maVNXPul61XurBhdxWBj5zpQuxJWJZaRRINneAPgbxi9VgCDP2D0+BfyeL6EP2MU/1L1P/3rFzH8bgdLLplRH/F+M37+tQuTXC7tP2NCqBw9ASLO5WhCgJlSlpVy+d6kqyHrlZgnrzHUe/M1hjMyeI9hhlfl4BXWUoTkAqsSH+PrQedgA6Cq98bWe3PPes4MTcAtEfBOCLqUOUFaxL9mDvtD9sRkc5SGGNnGmE3qlAqhABi9RX/CSWzYqceHRVoqt7GyWq0o4ziLdWxuR8gmOiqhjmVZrzvEbBqnwffEhBzYHS7bUQ5Gl5pVlJVgHtCft9+8wtLuJMAoz5hul9jsVYLDH+6Ah/bd+1JUTErZvYDOdpjmqA8LVA7zJ4VpJzftVKgY55Nh5fka4/W6QugtHtE1Ohh4347Vt2M8ol20/5n/8an6+FR9/GJQIu/zCR5VPYVIlzipwIYrnlwjVwmpSgk3oBuj85SHdVXiFx/ykudkrtMbDjkam1oCAH4Z286Xm4ltppOQ9fprrLa+s7aPxBo8ihj+rcqZwA/sEGtpXhK0iIkVozL5mOrPrLdYBNOqEGwMYRh6w9f6RUCQ+zgMT9F/LXEYUNTpQ2Knql4G9oNF5dyZ4qkQTKZvzdlkA7AW6RWOxmbE63pga2c4a9PdJKIsGut5T4w/JsEq4ZkAmx6kyQ92K4kEFxSDGOpANcVgm02iN6Kkcb1lVfDc5koTx3NC5fdCUo+iNyMdhD6aXfkJttf4SyeVhMICaYywm1FRqfGkJk1iLB8N1XqFN2BYyD3o4SFFxMEg5YFTeWOqut2qNyPN8QzNUHKw2SQMhlMhNDkPj/4rYt8HIWouB4BVIo+GrkLRWShzU8PCi5mvNX5uATknmBpK+Hm3AJ92i/U6SRGV/XCYwz6oUSxJEdEhaAi9NNNWx+TPeC8+zNm0KlIWZXiFSYbJ9CaWsEoRQq8wuNW10UusU4ySnloWuEKkNyNwgYhcC5ihV5JLX1iKmLkUcYb6w9kTe2HFzFCyOVqMZxN4heY9vXrwBn3avRoxOaG5ojxG7TTMtP3YfIA3kMEbAYqrER38huFB92okTt3B6xCPJICz2ZhJpWg6kvqSCq08fUnl6ksyAMBg5WuDslpSTDfeGtUOmTp5jEtKJeBlVHjNk2IAoBBt5md4uZLqsbcpX6DWG6UNqYhyF+QAytNHTQS9lNnF9dMraRbYJBgy6KGiy4hAP4OMOpx4s1PNV+HxczzRSQxk9/IFgLy3xGWZzjH6Fktxas++gX72DCibtrOjsNWVcR5qJghoC1TG5dBP7Wa2m87y4GZuII7YJtHnTHIzGwA1kTUigRRifeG1Gdz/iSsFCjKt7+9a5h8iSQ0tr1FGKckihudyg9m3vkj/bZuZdDlHLNN7/yI4JoR700XKnvKkL+U9/XAAEPoZj7AWW5NPwUBnvEdnMn1uPvMzkWqpHfGGtB7tfxXF9SkWSqSpkMTZ1Lm61EFGQDeE1BzUKTTzyZBqPd5ePIj32lqGYvTN6clxT73OZzdJAQZnWKaN2zAU38Z71FuXTWyCqv0FVG6QewkZxUm8R/ZiEA9iUWEc77G9eDKQicEZXhXpFCc/YKgzgtcL8hNuuYuofapWSrt2fmMuM6gR40dc84nfWK+ab2QGMsdvlm8TW/uO8PBNQHTNiTIcRsuqlLEtQnrCWTRjdBnJmF2tYo90WqXY0YOIFq2fYUMo1JysUvkjRBxDAGgFZigSMzKkhhjDQAIG+p1o7m9dGw4n1YftUB29XoPIkuZobCXviU12HH2D1fkJ/9bliq5rCuxqrzj35MRa1Y5dFbvR62vlui+KMyDXRMYnmAOsNeqnRlSNUlFJrYRkx2qdfuwYCTSOQMXJ94fFE9P2sKg5eTYuApx8rXyRtzL5uutRvkZ/a3P4tUJmS53P24x/vKv8pwO6VRaojBygeSfL15mXDNhV5BtFxZUKLniFOh7j3otlVaQcZ6g/QbF5iKH4dJzKuI2DCYrVT/2aEow+FS8p0a9OF2lGr5/TJfpsgmL7FAs6fiuEY+U/2orpmImNEn/ZO+h9po1ny/RXyswr6dfLk7gXg3F/ogvkJFzgYGKOWj5dBApoz8VPDe3txWCT6GIAUo5iMn+OL6r5od7KMJfvTlg+z0laaG/vQr6UD6/pfI6ZYzKruAdcyifODSL+t9z9lob20sEOs9X+QcNwpR3SHNOToZq+E4anPrOuDSUtMNJ/Q3z4IiVZgdtXXbu5FGc5yTxQKYGw/qjBKuMow8hY8Ml6nUpRcsgSb3QwfvHu3cm7WNrqu93W15N3R18fHT99HeliilULNxIdnhyfvfjxLJZxN55B3RlncIgjucLq30F7anKNgXbiaDXsQSesbUOlElu63VKwm0Mg3/CWTnTFrV73bIGjFcMlJlMcCZZhkZeRpBbRMmWXZX1MURalZXSBczKP+AJH4uyxn3oxgAuObjcwk//OJBbOeevIvXISN9gjai6O0znXOlAA51zZ9LbhXisF3dBV1xGoY3o8zZzJO6TG+xzPzm5WWH09xVrDR8lzXHJGb/zXmXqpfOnPeTLGk1DKHCZWbIrL0pyUoodEXVB1irlMBdPtnguJb1dtoz2QAbzeVIyK8IIbmUY5JBn/8XeUctM38iou0jJZcRCGQZv9dkelROFNUMDWgGk5paRliRk/pvy5gZzJyuyAsq/i4zy47xqKYIJOTMFEjMje2eROdVrglJnu6oa91y0I6K8NQWan/kBxgN+39cd9E0QWAIK51wr9qGMnJAykzuzzLtHsd+6vndZFuNynVd8E9LMJQzIuuykLsG6XuWzBDEuRpMFYrtd6w1qvk0K7BedusSMirdZJAWTO6mUdjOyiKpYshh14Rwzc81y/yVjKsSxn0OvTLul2r4yzncnPNdc8uF3yH6VWqnHjSQvgoXAGi4GBYHRD5xZpGaUFw2l2E11gTCJbSZz6fiK+9pbf6kQMGUqw1CwCYAEvsRBSffMdU2vyRl4qbRYD5sguPR3hAYVF7RVERQ0rqa7XMz50IU5l5C71u1Nhch3EFFgkechBGyABVdMgEtNWFrcc7MURJlkZVasoX64o4+JwyHmJi1lPyTLh/abuV2hjTC5oGzMCCrDj7KnWS3DLdV25cc5FYf0pmCtwC0XmHvXoZVj6uOdgszH9WYBKgu087+zGJ93nPCnuX3wTxCtTJMA3XXOLTCM88FTlkATKy6KQoAWHzBzL+Sy55k4qiKUhNdzXvUOjeCdbFe9Wqc5C2a55o9AmrLUP1nUKuAyqaDLDq1Iq2YBu0SbnMbr09Vruh44q68yTgmGoN4KvE+rqFannh2U6BaJHQ7MEzgpmUMNOQnS97vRlKhtH3c7ahF0pe1i3azcs0zVam/FN/gFnSl+137Z+cy3MGa1guCPqazHo7+iL70nRR/SVUFSzIgsOO30AzN4NZTHlielw0976HFIw5NLDS5axwfeBkk3GWx8kbTcDbpStKOO7yZvrR6COaVJHKJpGFvLQ148Zh+Ynr1UqALa1cKpUt2t/NIskBOlvoNtVJEhqih2GJ5jMpFGiwfKoZCU2vaH84cMtdKYHBJdOx/WP7XYDHkfO95H0UJDKz7Z7auO14S081nUQPjPEIeXWBa0krpJ62bDZgMqsZt7aaQJnAf2d8XzVOq4oL6NlXpbikEtJ1Oggkq5mOVc3fw1r2hCOnsU1S33BE4tBjorsgm/LtaJ4zwVv8Z6dAwBvreey8RmAckMNyGg8se7Ltpdzbq4E3sF7t3xgdK2Blg1sa9f8jvtIbclD7iHYrhyPtSfjverUEQgCFU5rWffpalXk01R5homVSov8I2YxgC+2SppeZmPF169WonJp43ZtS/XdMhkl2HswKZNlGKT63UiKzI0Pp7z+gmHlCB+Wu1hFnPGXd15fUY/QTEeqiFzvRz3kPqx9SVV+S2/ODecR71vAccL7PmaTBAwPubyjUascKdgYD1YZggBabpkyPVNP2bzckAqsQZRIuVpuCpsSgNRynrM0/Y3Wfpx5GHGUxQ4JOarVE3G8d8kTUP/jOAA6SgylJe3NGF0eLlJ2SDOc/P2ve29SvujNCkpZ8ukX/yGfWEoyukyA1qyd1MN4W6R8RtmygZVvQyWexwA+rT+kq9UzSnnJWbp6nZccE1n1eLvaLnhpAJ17dF9rvMT7Zoby3nXKSLCw+KBKe1T5ObfX+zqk9V1FeL7E0ZQuV3mBmfFyKGia4SxWIHr3sFnotpTwdHpDpo0sQGIIYjT+fLxaT8vfV41kT4ui9jT/nZ03WnnAYAqcssN0uvC837aVednQH7a0Hmo4R1mzlNg933O/izeN51/95xoPXjuns3HtpHL95WwjfWypJOq+W2cvep5nMuNommVRziNOo38caylZ+oM7Xv5O/lE+fskn0pgnun3P4SsOX0oFvC0ew48PQzJNHW0DL5v8rl2m19zuBvjsPp1YP9CPXNX6+g4FqFIh+16K50Z7YPSg5wqwOa6dFH0qjgOUG4/ZZNiorlxuenbFBFsGaS0GPRRKnvrfdlKruzrcXAemZiiZHvfFtl6kf0bHMPxyGdx0gr/xpAkrs0y/8T8Y3GukHw5Zz1kI1itxofWy9idkPiwRb8BWNCFtA4Sf6jql9PdovoSsl5NVxUvpKS9+QNajFdev9K+dUYsBD2joJt5T9jYtheuwHV1G3/rowJJvkl85gD80SMPPjefvAgG+57h3zWcaoJ2kg9frTvJexgqwdCrk6uQVR+95D1/J66r7APi+Htz3BaiKQuXt4+g7J9+gW6bBVisvjlcmOEkpOqXOaBCs/gnfwJ+2t/5e8CXpldMO5Fta4hv4zXYEbOmeOwdaUN2BkaR3fp7rgySQg8iNqlnm/r1BuJH4Ykd4aiBItHFLbUgNJs1cRUgHI74MeeCSfD5KzP3kZlojt+kS87N8iWkVkrrqVBzeUgrW28nRoXNtJPkf6KdOwNrsqP7i3MHQ7SbF1t7u7MxNGLtxAwL8T2DwR0AXmowEGPlDoCKBdtU7yP4IVFgLGPIN0HdvBm+4cvBbuQVaLsJVE1ybex8qACuTvAT+eJf8KH3QMUkvCvyakvkpT6eXZ4KgWV2sykVWX3u+SMu3mGQ5mdvIstKKlM7HtPUxL0+5uWVYq4TeiwnIWGx8HX3Dk86BNZDZ1l8sV/wmUOB0W02dP6x+vy3cLmRpUYbmKSWzfF4xJZM/JcrvTnuIl7Jy79cyBkP5Sxl4xM+3Qh6srYrnROasmSMT9C6vm9HII5NhIjeMD8qHaz4Tf09XeGovV1Nlnd+9GWWXSbM8AKqJs7SUq3iZk/l92xJQ2FoZSLyXnwsPTR400nBVAKDmn4Ct7tW9JekSD+JUrUIMV8ovMMfl4DYv9eKI1mS2BkqOyBW9xGIa7nEW9o1m4kiBuJfbOon1vjWGGHnsbOqWg63Cake7SV0o0OqrtAwOVhx1C/VNNAAg0Rlv46UJ84wRor3pIiVzPFL2svbepD1bHBLRKRjEy7TdgFQhBzcw7dnyAKgRW8eZwKgt2+3416gJ8B6ryEnFyzzDet2CR4few/LsT6igup2Djatyyssj4ix8+6yWMQVeiKzg32MPXZTJVG3erc0pG02jvyRgk3xh4oM4jS6kVcqQDVEDRhcVFxKiUid03L6P6c7uH9y7zle+fQSdprGYVaTlUOA5RKvdyCrztVVd4EaASXfUbaoNmCNqo5VfCFZZRSsfS1IjXwyieI9BDDmBWPznhTtQ05m6k97ZTr2pOAkL9a1ptWQV+bpKWeaa3nfOU5feNl0fh7cmNlL0XsGtpX/CUtiQpzBBrkKCmDR7fYSwPUNkLqPQBrdJjuS9xeomW1Npbw/i1lmqtpWK/jTgU5mudK39fbilL938fXYxtke021/dI3b5gY2j+JfKuuYcTFl5eWNd8UBOz3ARTkeOUpQ22tvfhxLCEvQFgRXZ7Un4z2R4djI7QUYnxORsUcUHXf2aGrrgzthZ/G7cD9VqEIhGWZlYbts6BGwd54o1qe/IV2tgUvbozVxKFsNfgvMsz36g7LK+bl+w1xfp9FIlq5WvrgUbpycoaVIpUxSJfezJMbzBKgVOnCY3FW9xWQv0ucV84gLARf6tV6tI5LfTlgmNfNCIsxV6ze7c4Njp/fTOvn/kW465BMBT3Gi3uWS4d84qcmhW6Gj2DqeZcrLbtG48zcmU4bTEekO+w79VuOTbUpi1EWcPHTRxpB/AL7/TDN+rU3sDu9vSvu3Qffuk3z7e9fcoFdKmlENwycvoAhf0OvqIGXV0yyqCKQS1OydjCdY2cLnr42TV95rsdjseLoVIZMONODDa7bZDj7QmAPhINKMsGSoPl3pnG0VybYR3vskE7UNphTCCO+9x9esoE0xrRgk+vEjqXQQ27o462IDax0drgueY60kLAlCa5MEOsWk892Z5wTELGLk7uFetspTjw4v12nlIOFivE2/c2B1358D66ToI3XYldce5beGbhG4UfFuLCaUMCGvP5VaF8A1Mol2Yl28xy2mWTwe4l6U87dVvYIaL9Ma8lw9Q6j5zSl5TZS8faA2x8wp+WDBTiadsjvlmAwbjScMpM8sMyrV9aa1PFKRo/0Dmuv2q3+0mFG3R7rgLy+61qpGzVh2E6AZAnDC7UpC1UUje0g6ap5YOXFY4OsDQtjqg0KDKgDRp5fUCk+Zer69GJ2YPN1e4RZkeibFFXBeJPlKChYhjYukj0U+0Sq1vihpRZEYvxJV6KAnoRUdlFH9U6pXHWV7yx2II+6aD3q9lrE2xo0d6TzkrqacAd9DAbej/4NOicR94TjLjE1lukTEkCgpOJ72D4zxPa4eQOk5gSsRUz+gPMv2XTosYNHHN85Jj5niVNBzQ2p1ot2jeAE9FdjcWbEp7rTbN805bRfHUnaDLUrWbMy7wzXU7w4LvyYuc32yXv7yWlAVP5b1pNfe0KOoWcxyihMrZaMboMgm0Ln2adEqmVtPvKOUv1AW3D2/5Et+02xUI54DgiJwxvCVRUNM80wcCl4IN2Nt31HXlnLK3Notie9wWoacyeW3yEHO1g8o7bP53z9IR4fW6bhIA4Epe6b8ggs3PSO1XUxT0+k1V8HxVYJXc0pHIZ86SLGQDK3WR7zy4g4jK/KcIpWgLcUeKv9qW2mE8MbkdrPfMIIr3uL44buZm5nbtXo1lNM3k6IaoNGWdfL3OrX+iRPeMCDZA5jkCOJH5vKcpTzgwv2xWI1onNOr0N8DhaAr0gHrDjruY+SwpxFlSkDq8QT2GRtl2c5QX/05TEl3giJLiJhLHy0oDrRdph1IZ9bVi+CqnVSmLcBopI2mUqlSrBPdiMCwIUiHASwJsqjfxfMJVWj2V1X5XrI8UPZLXxi5t4cDKQQGlnppt6ljVtleBXauA2+8xtXOL8Ie85GUn1oV9eGE12kBQcd3Adc4XURpl+WyGhTTaMGksZMgcJhpOWS96WwgxxkSURDmPZjkrec/NXCZjWyyG37gJoZvLPCrIwBq5lztEe6N40+FhRqJfSpu9I5Prlo0vWfuLdHMMkZoL44em/ADaLh82GgZari8mlK5ihFBCEB/xnmJ/tJeqSrVWkUFiWJVYZvxTXwdEnDH4OvqRJ7ch09pgpu52zNHYbqMfeb2P6GYydNWdzUtVOQriXw6V98mAWWxRGIl7Cphn0mKeLvEGSLOfboIDKLa4h2FTsyEE9hVBVJW/lCGASbbNop7qLUqeMXpdYqa9L6KcTItKMG7uPczWKzygQbwmgiHWiACJug7zPqpHag0Iu66bLTz7BFYaBeidLVTZdBSZTZIWmF5wAJpOrwmAheta2/IctT45emrPqXWUTAiAZFOn1D3kSQ5GedPNlBhPrvvZU3xDjIQj2YBBrjO2/BmtyXNikxTyZkv/CG/svq1BaMMt5xtDntu9hPv3HECKLkhyK0QiJxm6xOhD7bqZjOkEBNwoE9x053VjoMLUQl7j2ZxaewEDfmTYH/q5ynmFe+e2o9pF0N7qB7Z833E08Xrk0lHB5m3qiBEoP4EemTuDDR64ZvcqH8e65pSSkrNKzAPsPZKX8Nv+Vjiz1iWbWizD0yJlOIprh0hbIa7dK0VhFqVR7A0tjpaYL6h7LM1yguXhLoPBcYl7j8Bw29QSruNzDPmor8x0F7COq27LNM3zpm5hS4Jq5wqE2Cx5DG/nmAeyYfqn3gZiUi3VjcODTh/as1pfQQDgHdHNVr24I4pURtQbGr09klTwHD7o9NVYu2Ogszr+ecuBfSdf1T7O+/cCtq1wB7RtuXuA27PUXexKvMrBiPcYzqopTi4IxGCQC7IkZShBAc638j7Q5vqy6Y1q/f5H17xhcllw2OCWjCst/jDFMseLPpARszV9F9R3yjOVIWqbyvkpT3lVoly/umj67Tu81lWOr51HVhGSk/lZPnUMKpjMKJviY3qMrw+la0FtEjsvfXOM51haN1yTh7qvULMzG1IhAdY2de4wTBS6ToPDKno8n15qE4P2y1KXffvMg5mJaaa2UHbMq5DmO/zZGhahM6pdFhjpGGgHIW9+cd3tACwDg5YH0vBePXA7r4CN53dZd+xg1+td8Al+zeuv9aSVfUgCotNXN8pvjONpPfiAeSw0/ObYbS/drtvjwYPWR2rgxaCa4iC4bVwXAknz+hAw9E3IGCcVLNXt4gECKi/kSThaYNhccTIkKHjJeZBSbjTT5V+EgOEUg9ZVUTh4VdQG2FBV7sjCQZ5whxBWh4k5NEoy1oGAWX1Jv2k2SkvBIzAcCQ6k5HlRKNPZglFCqzLKHYY90kSsF1n2wWVPciL1C//l8Rf/pfkTzYyonDPqvBQCM0FeCOevfIQHu+nxjpCBEKHUV134b002YuL2/ZtOdeYfHJIV/YELGZSYNTb5qwXBXa9JHQ5AwTDfIqj1zitS0DSzw05yswkL1NBFlQS6d3NERbfbKJESENJeJ3mv0LadHpEJu7QqFZp82OfNMUBxMJgoDTdoLDYuUbldd7PCGb7CBV2JhsVS4l50mBZFpCT4t4xmb2iGExBxqt9pvRPNKnWky0oxgHkj7WTumpg8XwbLtjnnaECrU4PiHZ7J9sTwdc4+hqcVK/MrXNzEtd/9uSilXPtBnc/GP6/77pl+F3fH8ZTrU9fh1QJnsoH6PVqdLvD08pg6zboZT+2hfj+fwRYP1BTvG3l5mrzLT1wIsw0jIefpdPF9jq9Dgt3QnajckBxAriud0aer1Ts8M9dX+Qz8zmavSeK0LAMzdJWXjC51s01R1NsBbXGmnkmCewtacvFTr6Lid5qMl71cNUA5nnI4nlhd8DauMSAx8Kbnvj+JBjFpT6OGnDcNA7F69LAp6jkJCdoGJ7WED5Vz7iWciKalvfAO4UQNQcn/9xEH6w2OvuVNGvEXtaRxU5C59rQuuL6CHAzJV/sH3S72rhwXxQ6JHxv1IexWNsa9I5nvJiVcZla0TyqT4vO0XBympUqwaB5sHsXTRicvAkZGj/IjvIFnjUpHd1hVs5zxm5rqMVxWhSNfTLVI4brZ2RueAzzMsqHt8d1vVOPSC6KJicol4O662nWgXZ0EXfWalUnWqqqk1LCR0K+u5dm2RVjvjYC+xPasd0+z85Iut98AamuLUq2qnEpRe6tZ3lZWG9irPP6AExC6Kd6rqko1ieqOG3j8juvrgpoAL3GAilncc5DUWQkD/Zpq1k4pvu6BgBFOCBg4KWE0TWZgI0j0xhJwjf0HHmL7s9C3oasCacn9z2On4r5JSipNRI1y/YanDaE8n92cECuzN6iv3njKeTdwWpaYP5eDb1Y0G7p5uIaJvOnGuVfce+/LX8qufdkgMScEmSwmb1O+eMvwLP8wiO21N+LlaTWTL3tkrt/GG/h2hxKoTliq1Nau1meWzxFfr09IODlCuoMS1AkMamHgHVeOW6JmLWAM7LunJNPK89Ye9D9viZeGDFUJNslp/xID+CmAFLFxfwJzxMYH1rBVpwyUcXpxhmdpVfAYQJLEU0ayGCR0u5oej/PJZvvnp4K2yUsYtpfhNYjCNoImd+IALTD99rwZ4mLeFPHxgZh+fDzX1eMWFKh0LrNQEKU9ULgI0Wth4B7b21ZAYeMuQNK9u0HJjPHD4yaeui5jne1iuTiLokcyhfojIWw9ksm6HtVmQJUQ57ix2Z43nt81nr/fqVit1fh16mOjLlWsxDHNpIa12/UCKd+QkQykPFzkhbqIWW8Qk8VVXi0gd4yjHjX788+zDbgD793fUHCPAVgu+UjP+iEjsZX/pKHonNQPGYD8+6d0z7B0jpji8iEjqGv9KYMwFnzpjvSggfg172fVgG/IjlQSdcyWd+u0/OAH8MvLUHUYJrrdQCpETJZfVNw8T4u0LM1DyW8K+0HsLLH7JPNNG5w9h3RHNgCzMb05YBN9WrdspVdsL0trXyPN8JJe4XZ7jh+306IRljAY7h90lJkat6mCU0PLUhwegEbPOSkx47JnhsnTmS8QBPxR7hqMOEAS0iwG9BDM/aGwTMZ07wCqm3th2NXJzEnmbzX5TCygPJhKX6fAxJ7hGWXbTf1bJ6LuzTROvYoAg0HC7Yh4aERSQeKs8rZ1ILAvL93wBvxbhdl2B1L59WlRJBiM+xPjOtqq/7QoAghU3yrj8vlqk3F3fCE1SeNM6nYT8brbZVbTZNqSHmnWbxPy8PjUfnvgIJtjuHPUzTG2WjBtt8YcJpTcOyz0dtlNIt0Rbne+d8fFJWtzB+10YcpZPp9jFaVlDK4B/9Biu+WbgFui/EcR7nZJz/jDy6xxMnvD9wTAX0mdGckszmt3Gr8S36nZlnovS/1KlF+3w/B4Fwa98nbmM6LuMHhGnMz8pNtlXv6YxjXeRnCWbK7+PRyafOFM2cEALBDVP4f5LMmlGafbVX5SwERs15/Wa//TgbqlLMmVlzUsdPZQ+13eUMXhKwIG8pa/Dg7c7ejlZazfrtdsve7wQAUerMDBeq1vT5Z868u7nBuvlYsMcu6guPZsX/4VQThRSpeKbCuFe3n5g2pUuR/oHgYyKMF+C1X1NiTWYu7H+3DSxsFW+igaGVWHOqp33NEJKGEfBeXWvHzpFNmyjZ1WmnLHMy8F7NdE3kOdNFOBrtcdP5Hqm3QFul2BozJjdL0Nvm5m/+nIXRm6YxQHEtjrSOLftqsfQ0DQ15GWoaPnGWmJ3600WB7K/FzHl8Mfmr7q1rILf74LU42+01jVcnKJs3fmvgrL4pxXZOsngyZH/BVOM/dLHnhzluaF+ybNMpmotmwWtR+aNQQb0CotXzZLSpYhLVqFzftm+TzDhOf8RuutWoP3Pzdry4ilZzcvCcLr9Q/BfaBPhSOOl+2DWebCM6o1Bbqhxk0+5Ij3zgU9BYZYtFo9WWHWDtepb2RxG7b32bggggz1dfr/IV+viSXqHbJeS1ZMb/4jwcE9+YkkKv3HiA8ILNBPJMnlM6xQ7hWVZF5weoDt70OCiJrKO8nRZTb/up0jVDcQ5JYCyVYA29tTLo50vU6odRctUbHPYIqqfSY6Kjsorac9Rf3h9Ek5nJqEgis0fUI12o/oeDoZiH9QHy7Qam86TJ+gRbe7eFJ2u4n8sNo7ABs6boxlgtL9crMRa1MJFkdnegmuy1u7P+5cdX8rBVbftLUdC55mGc7u0ZW37wI9yXa2d/NGrNw9urGbNdCFbGN7Fxo97tGJi8SBfnRD23s68jb2XTuzTSQCffpNBrrO8tnM68neticzXgjshh15LARSv4g/EWc38gIkKkM+okc2R+mjXnRCiht1zZy6RzLnitMtpXtMWhT0GmeNCHJpm08wkOJY4OqngOtsK7GraGKLYD20NgPM9fUz2hfSp0wFUsxf83T3DyybKdRs9Ar1h9UTp8iw2tsDJhONpc1JBQUPW03MhR4o73Zf4CTv6SJHmaBoSeEkk7vCLJ/dvMNK0pXuKXLgFQBQVs05Xlp1idxa/vKL8gAMbIPLvFxKrwfTjph0H8Ac5Qp71GV4BPWhf7CHwGIAELizkCd4TPQV6lGYhde3b3QSall3IBnxIeAJ1Uy3YLXdRaUCy2uQEojvB80wKDGkkHigFKwcD8MRazh6QFQtNIEIyd6ecVvRWEP8lAmcVWSayvtWjC9EUahrMG1K9VJaou7nAq7KbhVWDZVo018lzNlvlmg23rt0rvEpQJUe5mJ+3rBc1h7melomKYO578vep0ZZgoPnV5CVwUOsUhwJVsY/1Mx7r8ngOeU0os8p/3hG2Oc/JP0OsJtbOU287fgSPfM7uoPcDE6ecMMm23pfjvXhzOpuPnXTjGXRO2hbFq+hg7cIITyyeb0kFz9IqJingIQ7enltiSEHCda3SaGAfOG6KXofpIpDKrpGyQsZkyKoAt9BYJVOycJVqlelQZDpWwwDY2mINO5oGp/0eFQI5u8YEtP0zh+Wg+Hqgzjhv1O2f1kENu5IaVPPrfnX/oSJDn2qRUcYhWZDocEBBgb+PujI1IX+OxumIKPBxf4oEyzA0ZqsIc4taabeik5yF0k3nJbf6V2TuPOUmIkR33ikswED483YBI25ti9MxcWGsBkxvbcOmdIJndu03qtt3zg0JFRT7cI6DSev64SKu3TEVnJfesxysMM2Xal7b38LMcKq2WYuIBehWqH+v2etLCEamjzpEkX13CA1GGMkUJ/QsVGAGNMB8wFEtZSK6ChAqNmAen1avPcpgZO7xNsQpL0fLF3bnc/QYvof7c+QpbvSJ25vvnGoouCmGYXOZeM7v3Uj4dZwd6GQQgIzhpHLlgy0vGYdE/QGYoasIaONsGihdVhYIIQsgWGwaTEL3Vpdon3Y2S3UULDh6+hbC00fvVfy2l7YoKykBRO1DXbkStlJKdueujnxhTtvawY35q5tyS33QCwF9zdiA57EwpMYeBJ/TfiA2FUL4LPG97C2tMnTie7xoEmTfUy2r0dNHs9gcJCY45avsr8U23LUbzvRLQq1tLQeEjWp5BY0kvxv+zDwUdgldqPAYRKQWMS0fZooD4NB0njbbiyktr3r/MJBirZV0+MhguDt6sjLLdw02nEsjraz6AYx7ntgKkq3SQD8LpiSRo7VpKQxQrcZfHth5Wsf0R2ZwpPGGir+Zrnm9+fVqlmk8aq59E7JLa9rrsl5+SZUMsBmbOAnd2XdWjQ0/NyKSuH8RS3qZ5FAtGT2waIWxWSD2GwnCw/sgwwYMsMtFohP2C1XF2i15nbVzkUV8smQAjFxhm54ajK02vnn1QrksyQx01yv+RNEPJQCUtlDHGVPfX8rGfo5mlpOOMHECWa69ZHwvFptORUW3pkgodE8Frh3KEgwwtay6e317R3IskxXxjYfwo5VxYMzqmGj4b1MV+YaVLJeJ8rg/4n2UxQfzcWiAMr0by3D4JY19Vt37hkaEXtpdUCru2Mx7NA9rVk9/vo818e9+KRzwXFJfu+lNJNh21uVZjbjqARN/hE/TK0lpbaWZ7hoq84y55maf2pwjQ22YGjV9IgZVGc6CrPvulA8IfYSwIQiMmYTANke36PSdPzNn2c6blq81+uv7zYme7bkH4neAj/eRS+Zw1e8SVdG45KuWsbb1QoTLT8ETMVv2jWmYZvrNGxrfbjV+N624If49f5ZCl9n8jtUvg/D/PvbmvX6PcjY/DuMmm+2dnO3VVMd6/exBU53muV0O//t5tN/gW0zZGBU/7a9ZDTN+P2mxmW6UoZG5SrTMDMqcxa2rm3/zVbHBtrbkOwtRMuGt7nGOGay5pLeJb6RpwEXTd5c4KdClDMRzkS5M/tt1y4Q7k3xvHc+x/yEHUparYS0l5R9i28SBjEYEnVJTu1te8KeylYTIu8+BFJbpvZbt5voX55CMEQKnSsYiUEwNmTIV3cBVgu9Cm61vtIh5nUXSsTU3AATQAKwoUHTj5A1PM2Y52QG/Ue1MsyVSZgzx40fERXQVE6bApemCd74f5deV8ljxmAY0E75y4Zatl1cx+nK6dUxfkaNxM28XfWUWmxZQrBddy6UtUu4SCnkzGYiXfNx1N4gpj87olYJMGj0GuhUceMNWG3ZBG1w+agmL2UHHjNsv2mO2AyovUm50RTrXQOp3aGGyet2EzNrCqAM39JTZ4JTd2Ri4iKnypSXS9onY3sbWfv1CFU25hzAPOhhqfRDTw3+JXkr58QD7beOSbTJlHnLBpum3cYp/lBzbuB4dpqwx3PT99QDyp324R3m4WB7bQ70AcznQ/nOlhW2iY4NRH+BEw79AYP1Otk9pUYFH40M2rd1vD6Wbdd2eBAIavBDULHa1B1q/WC94DDb0GoM0lnP0X1W2A5v6wmBA0JJa3DteHmxik2Oa2RZwYSDgZY1ZNpvHEhHQdwkGmMykalRtdDWSCwgRyhYEuzr+pzD01UNNl9vVQGGVH73UtdtUe25p+4GcnaHn3J9c7TjU9+Uau1lBpIK1IafnnNxtEoYIBnoOnA+4IuPP3DvjLb6YZvAF8OqNMlCB+5SyciFrbGxquHoSHvkPZfpmkuZvZlWPEojFdcU2aDROmjW5u+VF5RleFUOxmMMRR/H6s9bPJk0vVCb2SPMLaA+XFX+iFD8gNU+qCSjDnytqm9nHLBJSR3pdoQkocQEIUjgvfiRzKl1s8LiOUk4wkBGyqzXNv5CBg+LeZH5kYSLBB2eoaxOiJwdkUHMKOU2OD8kksslHsvLt8lEcs1yF5E/FwH/R6Pet/hGbvv/JtT7A4jHDcrxP4pysSGfjCGJDd+QCdTXq3FWIwjM1TvCEsYALBi6IhL/YTylDMewTuj91knoHVfkktBrEm+g/b4kGm6v8cR5nZrX7stjbl9OAKyYvc7gNZ2mBT7K3EsMSuYkwmZ1lEvqvM+d91Pmqg/X6xiT/fensWRUV6xxN8Nix8YwHKZOYvCcTq3bJMFMPFdLE6LpFOrly5UK/VUZ3hRqvTp789rUSOIyJTnPP8oC+7K1GDhNP6PZjQ0fbnXYu6DZjVb0B+t4mOhXVYPR5ZJ4wZeFSY/rF1RyTB2Pet+xNToQQ41lEjG3veCgN8HXPXmDpYAeevSkvJp/9WQeUZlVC8WKA5Cb+phmRtmfgPirJ4/nXz15LIo/gp1wuzKO1Fzsr/3cdhdK4vJqHoNRePztga6+eiKjxL96ki/nUcmmKH7yuPHmQ0SJvKocpQVmPDkAjx/HXz1S8J5jfrQd5FvHqc0V95hMlC/nMeh2XQOCvZq007mWt5n0np+8eZuyErM6mZ0TpqhUW6GxntuKg61FjlzkAVvLoa0N/PjqXciksKWoH2WP4icCP796ohDnqyeP9Q9JRJ88lh9jmW0QI0ymNMPv3x0Jct0AhLICqk0nTQ5vXr/ifKWvYBryHsPlipJS3liA4kzPN4a8R1eYJPHXL85iGGcpTwccf+CPxb4cThcCeBxVfLb/NxjvYSjvBO+VUikmnRi1NsC2L0lDfRmBG1ROTARiXmQAkpbRbfvq/W6gKYBIx88mKgGxb0v8ktGlzjSFYWynHgNvIo3oeG8iPLwWd0/Pw7xtx/hO2sbxclWkHFs+QmX/IDzOScRHiUsSpHnyTsKhjxfnLDGo8oZmWO/rkrN8dViVnC6Py6ecs3ILQQ0T7WYyqlZrW+LrsJMPQ7DXNnPWsP+EDMn+vr1mTjptJERxucP4w7Ig5YCUB3FH3vbdF39smoSYlAeDGKzXhnw/Nb0I9tF0TxF2Vn1Ih4D2CM3UfkJIUv8Xr1+8eXF8dn588vzFdlBRAKmO3T7NL4qczDWnlDH0+D+T0SAZDRacr8rRepnmBafrGV+tOS7Ws7zAYLAe/2d38Hj0l8l/JKPBWPxYfwLA43kOZ6IBuYWT0SBfpnP8y+NkNLhYrtbzfLb+dYXn619X8/WKzNc8n83W1/hiBdaCIaKy5FKUWK4+X9P5XHxcgnVaZbn5+NmazlP5ja6qEoDhRVriLz+H43T/Y3//73u/PJ7sof/45HFes05zhxVKMDI7DYCeii3JmAS8epgxMMKDRCWaNSlmr1NGkviHp++Oj46/HkSabxEMZ0XKdIaj9+9eRzKMJpL7P0pKjCMBwMHjx/PelD4m88clnlYs5zd/+VCWIAYwVnUH8Z4btXzFHPENMnS7kUSkRoGizkgFYwDkzds6Br+jwuyH9SvAxjq4foI6fScNK7qV5+0Ab+r0qezmNu92OyaMPyGI9hTUgElmkFDvbmlz2xHvydY25gxy+NAbltT7Rxrd0XgCGeoP2ZOUzeW2ttFcbG8PkDGbIPtlzCba8N4ARI6KhKgoVDP7Ss2+fqXgWKJKgcAaQdIoJ1EJpDr55JpYu28KZEBoKmAFNhpaXFB7DS3uQ6vqdnWn8mqTvIYWV9DK/Zu4NbRwA1rKW2DJ4AVDVyyJU4ZTeMHglBZwwWC+nMPrCxYDeK6+T2kxZ7RawSyDGYdFDleQS26YZ5DPKOVQ5vvDaQa5qHet6rEVlBz2IUM3LLlm8JwB+EE+XDB4w5JzBmX/WcZwWcKU8XxaYJiWeYbhRUGnl79VlGM4TWVCXjjFhGMGM1zADPM0L0qY5WlB5zDLGczyK5gVUFqvsfhjqokRYgYXB3DxKVx8Bhefw8UXcPElFCMWH9TsxNRJCZdpTuAyXcElJhUk6RWkBVwxDEsVxAXLarlM2Q2U6gJYFWJTqPnJycD04oLBdMoouVlCSUrgBbzIcniRUXiRzyWoczEtmmE1mRmBeAlnlHCYS/iLgVxeZLBIL3ChRpOyS7jKp1xM7jfIqosbKAEMS1imyxUsl2lRQH0farlKCRR0+BKLP5TMYVldwLJayYs9ofTCgZzDCl6lDEpqKOZxyAA8Vat3kU4vBWBIpka7YHgGxRkj3RQKSuYZLqdwRUsB3JJN4YciJ5cDUS4G8IVqpWTTEgskOJPrfsrgCw0nBaUpLstLfAPTIp8TmBYcphWnqyK9gemHvIQX8yktKIMXlImlmuKiWKVZlpO5/F2u0qn8XaRlCaX3DVQVprQo5T8CElO6XKVTDgWnwNQHyrISZinHEh767Fd4RK+lpANn6RRrHCnhAufzBYeLPMswkcAoUjKHCzECDPNSrJGATjmlKyx/rRhdwcucmFWU5cU/VToXAKQCxbI8hcuK4wwSKiFM6DVLV1AwqALr5EAYLqAMhqEFhoxel/IfMTEm77RSfZZTRgtxtMJykYrn/KP6p9TowKZyCCVPBdbUWJyr+DJ5xy3kOS8kfpBScFlQrnZVYjG/K7VKKnnKlZr5dZ7xhUCdo20yvdZ16UMMZ6d0ifkiJ3ObRvSimjm57zw+SVcyKa62ckkOm8KHQBwVOzmVkWZUUmbu00yEHNSqc/biR7eClA1008poMtg6tz70WGaO3Mc6elYM93b3YDVbhUlWj3XopcHC08vDgl5cYIbrMpC7/JbSsYqTmAwvGE4vN/yu2rWMDzwr7kU16/1Kc5LEcYutrQEa9P4T0zxOl7jH6Wt6jdlhWmKVzOcDa56O3ERni/5kJqj4idHX2Fcc2FNWcC8eu0xRf0ifMHPYU5OtIReMsGCWKYCFOLzTJYYVKtqDOmsNqrKHvOZzhqdsXE263aREc5aUQFA+9YKgEpYoIYYBJAA4jNSWm60l89jjLF8mAGyAhjOMYtCceRzFsICPUPwIvhUdw0fxI+0Usx0nN402vorvruKtcI2ED1nf0OJ2u52L4OukueiPA6veBMZXcdPuKPdq24plq7xlbVtlcC8EfARUBKI4VBg2cupbWuZa2dyVW/j5yeF7uYffnpwenR2dHJ8fnhyfPT06fvH8/NlPwOz0O4q1VNIv07zAWcSpEQsE478sogs8TatS3SaB1cjl9Q5mNgMhKvRoxZXU61zHqZMUM/R4/Ev1/G/9/v4v1fNnL19OxOOhenz58uXk8RyeMPQ4Gf/nL3/Z//+idWcCHs9rseetpwHuMbwq0ilOHncfz2HcTZerYQzs20sG28gfd/8S7yUH/U8//49ELeAhzfBTnvTB/hdffPr3L8Ge//4A7H/x5Wef9sHel1988dmXYC8expu6k5OtnTRab9R7/EQOueDuiB9/JV/Oxcta3HjqTNpVRGBHvedCZTedj89evHn7+unZixghZzdtEgxGuKebr+9DPVYq/Hd4/uLDKon/Mxnvw94v8aP/d975S5Tuf3y6/3N//++TvbUSsJcpZ/mHtT3b1+U0LfCaUS4fLvH1eoVZuRJ87hUGyWjw4/qn9WcZGIkG2PxivSgLkKonvMIpz8l8H4yS0aDICU7ZmqWCHwf7c/EDEy5KTtNiuhZUGYBffknG+/39v/f+H4z+osY32fvlFwA+iWE8jwF8LoT5ihW/JMn4P8FkD/wCPnkM3wWz3OMx7h2fHL9A/QmKxQ91Q4DU6BxMUCx+qFenZz+9fiFvDJC/9MvDd0dvz9Bn4q38qV6/f/cafT5B8ft3uvK7F6cn798dvjgXX76YoNh9YW8e+N5jfpzrm9+wpud3KaANKTr4698/7TKbB1XGICT6M9o/+OvfP+uyNYG4l5NcB9vsH8BOHwxEWVKj4K/MD6JMZMu6JaAuwnRaeSLvj3abJXuy3brF16wRuyQQsRzziZMZ8O4ir+4u8vLuIh+3FhEAfcbQbYn5ofI7EDtK360LldbwHaXybg//7YvlBc4ynLW/2DtD2p/M9ZPv8Mx8oFeYsTzD5sb+5vtwa0JIOdElSvtWnDxPSfZ+JWQSr7x3u437Raeod1/p65+e45U/+OdOvl/zRd9rcyVIin5Vyd6f50yRgNJ//w6TDLN6mjJx/lvJJH5XYZbb8g7+f82aWQTiFx9WQtzPqU7lr9z2jvirtHyGMTkU88WZPO0GUV1Y3jWpnGSyKBVVopzLC0SnqkYvMi4mSjU2MBnCe5HGD+c9Ee9j1w+P7qE4OuJRifGyjIr8Uh2lVzm+bl1zbfsvjXVb5UMSY1GCSrRIr7C+ElOAqR7kq7QUA/eay0mU6rlF6o4kOWFKL6NRDGAoMKfmCGrvv9+Y9DqEZJNQL0Pnb3oT4THlE8QhHhfib6+gc3XBsZABE+7U+IE1cgNq7kMg23NzAaZeo6dcSLtcsCSCAUnrS0Al9CTjoZIb/uyTSfgda2cm/aRWSKLvWCPuiK/XCUfaT/w83vuOyfAdKP7qcCQAeT2Nbx30y2fJS+KkvGQA3DL0kugMmQkzF5/hXoZnls5I2ORkLmnlHoG5UwX3aJFJQbAc0wkY+s9ybi9JkoNaTyl6+Imh+JNPKqKiQLIYfiNfYBmyVAPiR2cJbvNs8BODKv31AOs82BCTaboqq0JatAeCO3eeodSK4574s5EdYyER2fY5rWGjLYtJJ6lPDhmH586IN0AxkVmDbXuk3V7H6UMeOjsaQ8w/hBhtUo6d1YW4dmDGvl53XpFEZkTREp8tX47JRJlIFGf9NUuemRufXSopOpc4oIISYb4XC0Sm5geD/Q6qewTujfaUNtQTQsj/tCvjfnqzIp3L4Go9VPQ3ADniPXXDE+FpTjBTVHW9NkJ43XZO1VauM3ThIel2iYzgAMQ0+uXnMh4g2ChpNVo4sK5N0WIen332xReff/6ZwApvU8hZjDQXUGfzl2cRBvCZvTZNHC+2cUfF3WOUajV+6KI17sKzoh4PrUYvO9e/bSpxwQE81+NUC6e45dqtJdhUs7q+Ad+vmmrIl9e5mMSn/YPPPv9r/8u/drmCBridpiWODga6dQUcZyg9Jg9QLVYOZelPTenXW0qf4Q/cAcWUuklr6xzrnU7y2ad//fJv3eZU1NDqBlZuA4ltYb2+X/WFC7+DJ0/w//vs0/rrjNa0+3YDCeori5KBt2BEQ7ni1f6uEgw/lQamcX8CC0THB5NhTKrlBWZ1ntx8lPBxPkEFJGu0oEkOwIDJFxsAb6VRDWeGH+GwvmVhwKDz9eYoKwfEgeycNhjNpoLGJhc002lmzRslFCVETwOIOTBExgcTMEiohAQGkIUTArNAQmBBMnm3Gw4ZZPA5hreKn+GBoL1buXADCjm9xGTA1N9v8c3gE5YwsNm4JkDayGmiUU/RC8sjjfpIEDymcWK9Fs+WPtSvWU+rH2qyYDhHIfl2u3cU8E8xIevw3rHMPK7ojT+8rftL86IDLo++GypP4x9weulxG0sHY29ogNtIOMKBiyJ/ZhsAzA05CP//7L0Ld9u2lzj4VWT+OiyxQhTJdl5SUG2eTdokTuM06a8cjQ8jQRIbGlRA0o5j6bvvwcWbpGS7zcx/ds+ensYUCOJ5cXHfF1/k7QTIp9wm6EaXB5IbixiharCUOwcuAhQjMW2WFGpVBA8DQliE8Ilsro8ddGxMAlQvtvOT3M0OjjN7a1SEjaqHhEM8SyXQdDF8NRkNBmGhL6snoqECl6oZXHWJipAPOQmdU3Se+wnJdYcZoaMsDPemeZShEcpIpubtxNrURbgghaiGE1LY7e26PeKp92owmj4kiRuPt3ImM52MVj0mL3YdtwL24UkeVXhlBounXbJyp5XOo71KDUo2vCTq4lrxXFsMv1F3oqBAlhA5U8YHXmrBsxjWV7Euy3g6Mb05i/aktmjpPLpvbhW5onb80obDVLbOfhlRN5QYiIA0FobmeJZ6Kw9Fy4oWeg6XeDS4WysKQxhuZlcGWmhUad5wHiHgNICG9RYHd+/du7cPXct5WjhoNuuRMb0T6vDvBS5If1Q8rPRqF90u+pRHVVzYtR4N7ALslQb9CDIwDOGUMLfD7sD7VbqA19i8r3lbCn57vkeKXmCGPsg8s0wudgw0MpoiyLz0J6ICzr0qB8PMs82qN9EfplpOLgn/45zc/q9hFP/XcNJFw6jXRT/ctjjwWa7sboMhyB3j/sRK9KWVynGukWIMacjKeH+iFXZxEGDqSGze16jfPm6LIrsmVFDisClWFG0aeVlDXbjCBU7wFK/wEs/wHC/wGb7Ap/iTIchonQAru5/ziKEur5Faplz8zVE31au67b34m6FuJesdXllP/C1QN5H171y7vvg7Rd2V/O7ujb8Tf5eoO5Pf3/vb34u/c9RdyHbu/+N2xN8z1L2Q7T34bu2Jv6eo+2mk1PfDhrLkaU6LDstLbbPfOc057ZTLhHUedKiRLRWBe6I/541EDnRMneycwyCwtY9q55+uyUBlLp/nNgXKpcEnw1sD7DAY2KVmZInL2oraeVWuqtL8lKQdlZJBUwo4CnDzEERzkGjbKYL3r33yuI9r9HLW8wsaFLNXQZS4BHbm5DTD/oU7ZNgi0SHXUyyG8QS798qwr2YLbxSiHl4y6cWPBcaWT0lZclWoLUKH6fhU8AOy1FxFRjrrFwOr6he5VKh8tao+ZelUt6D6S7KsVuKKUvP1+k++wSuvV5C7whOYg6vJ6BWSjKYFqbd15GdQn8TLs5HJ+JiFYZRBXPfpeh1NyZ9KijUXwMcQXpB5fUvPyNzdpwu/BuzpqXSs+yTTNqRhGJ2SaEaq6JlYX83dfCIzwd0Icm29jieGkjsBUltyRZo6Rfic9EfnD43p3bmm1Z6QKiri8wk+QPgreSIaPiZP4v0JfiY7fAKd7CP8njwTb1+SZ+IK+qyDRh9p72N1DwzuhF/VVXA4PCLH7s04GCqU9pkcb07i8wlRjNJXzIrhewlfLzHL2euUpfOUzt7IEm1MqWXon3EhE7QebTYJSWD+YjZvnbkneu6wMnL+SWP+j0gVJWL++2j0FkYk+L9hXxnkDB+JOVMBWjCUR2LuK56v3uijIK/4NyTKSCbG0TQtMKlFxSoymUiUy8UtxWUvulZ3OeRY5aICm2wMI7RsxPwAldKMEPJvrttXmNJn30Q9r2BP8nOQnUnLMdWarNeeyyoILpFeL+iuHAfToEvzbnf4C9+4UgUYyy8QGlgFTqAqmVW0RHgVhlG5JpoaRvg7YmMHC1OFmss1+U74eNFAwBcuwj2rY1nuYtncYtkTH8m+z6MTZBDtWw/PnspD8Elh2DcWvV4fra7k2m/BrMu/g1an/xytPvLlHBCOQc0cp5qxK5SnzhGHPGceJS8A38jL9lJ0yUkOTMQ4q3kpyGKc91iBhvrlk/xUujAEOseMkbyMijD02YICc2Waw0mmRvUuz425WgpsnkyXaZmnhPRHyUNVqo9OolHNlFT6izgRCHckWi4d2388FUd/KrDvVGCGFgPrN46s2FqJ90f5Q9ZTENVicWXexfkEZ+Qp8FyWx8LRiqQ9g+VwNCVpTyJANJ52g2HQXQ1XSNpfK0vFgtCRTUIrOBf9KgyjSt5gBVGmcgkprMRFZtSLqvWaY7fXDI1ob5YWq7yAvCaxHrXkA/MJSQDXTvHKrsfTvBbD2KBKowdx5esOPL7LPeXUnqNAsRnrdBgfR32B0yaLDIZsnvwLVwo4nXsxr0mq91zNYp2FFWfBu/RwRbKxPibK9oibpyjDKRqmo0pdBNW4cklmoCS0oMmcKFk1HRc+HDKc4wpzNCwa7ikMothvIOB9BgcMavocdGNeVoVkuubjHNKDZklRgAfyMNdMtSnagMyi3v5h27ppQN++Pu+4tEQRzLzxd0/RZSrg1izUyCw+0BdqhSDXSZdkCiWkxCxn1baclVjOY3G3QjatFA0rNTdTaJawPrv7u2bXhImMpDtgIsU5GuYjR9pZ0NIIsUXTGdpETSnVwb6G1XFa1y6ZUSvktNeHQ/lBSnglCYFf5+QHHr2iCP8FT68pwq/g6WPpeDn/3tBZdhj5TAXlfJnqGx6cphd5xPF7GpUIGQZMytZLaRDtKRNe2KtGU+oQUYm8or33L94dfTx5+fzkzdH7k+dHv795quIEQdqiPyCUNfjGuFJA45MHfQr4cVYrYormGdTr096JynQL0TXl1+K+0VCm1QIaSWQKN7zOJaX8l/r7Ktdcu8yyLsDuZEbnJnl08fjiV3oRZyAGraxM+cRUiCspumwm7y/AfLa1LnkuVrJCgssg5EM+VlL9YgM23jD8evyGMIy4io6+R6KcbKmGejbGQxhGvpGFXT8xyVOw/LFZhnPnU/TTrcEm4mi9lnEiCCG51zKXbaSFuL6R0kgn3nSNP5LXa21p7WYZruXOYL+voG/LJLWKQnv+YwnViYZd+dUGe4ufTMiHvFH0XConrhiaIRkONSyO2XAbGBpvpT9o5AlVn+duYOErNK53BvvDetYSq8vSYmHZBlff9IeObUs58gWHUBbBGWaCCkI1AWL9PVaPA1P14BpV9eO++EpLsCxFZflIjnBK+qP0IR+l3S7K43RC1LfpxIbkpeeRJBNUmu4SF1Esj8sE5wghmd1W5b4tewIiPMw/6O8f/v2FLCNUW8ZdS3jN5ft7S3eTZSvVailhQhHlVy/Ufv/w/pDJxuRrMT6vxp27Q0ZUEyYcC2AwyRoRwloyBbP1enAw6N8zuH29bskcLA75kY5guV5Hui6R3yJs75zxh3zomIp+c48VoTv1KiMbp7tcr8ufDASAib75dWuAcPmwjxxxqY56F5cG1fM2SxRJon/MpdHaY95rGhSKTfw5F/86HMjjmr66HCc5OKxs0ZsOac3y4pPoct8okn0dLATeMy8cDxrxRq6sm/QXZMWg5T3ATGc0aNb7YsZc/mTyDI6pVNMwMUST5b8PiNEY4qktcz67NRAf5qvI+2ygTOxcMsgSOr/VpNQOevrBfwWt/JD7nlbGZizy1MmaEgDn03KZFip1ld72yrDTpMSVJeTAAp7hqneSMsEUklw8Kw6RpLiy6k4dOaMgGa4Aip7SuYpSRDiujFNrVGKKrpP/XXbZjK8sIxnGE2ySckJF61/USVkH0rSJPbu0MjgjIYGfZexKzq4RWfwaQ1Yrs33MZpAlDBKGrz5qDrisDditHZc3G3y5K7m0y9zypicLUxbVnWKZV9ms84l2NN0UaFvM01y6A/kbr7zQQfHenzTNSbQcyREwZMSY+WmjcDHA9TqeYOAp8Z+QZPgFB0a2pyPrOeHXM4+LsSzp7+KTfs38BAdsceuM8kKgbszL3lzmvqLnnV/zKIMHmkYZwpXM1P9XifCvu4+d5WK3Hbi8dyJWipRYPb2jc8LED7M2hIufNHtK50RVcmwlBKnQW+YFLBB8Kc2Sn4JVcs51e3p5RGs3P4JZPgVh8PYg5wJKmFhZCZ1ilCrOH4x8q9UP+i7nzcQq2zW+PN0yuO8zBg9Zbh2Iih2p6/amOStKXonB3+zwzpoBse3s3tG5rhAJaN0dSpvWPzV1IIVAuYleuzz4v+sCNIicpgtlZoN8W7wwdaea7kw4TQngOkTpLCkTwvQrl8xxHI+vEZxfYZqr4NZ2+p2gk/4vgE5vDJJgerl1JCYCB3FHQdwjrOy/9sowpCNUEjDNxZRoEbu5hcZqPjLZSGNuTGX/+ycJPOrD9UDExtyhP5H+iOqgOyX5ljtbjSkaCSLWeuWA/c2ONCte0CO/z5hOZGxCx92DptacoMN6SVkm0+X7/INLWb+jMnwewmzjRma6zp7KaV6BatpW5oaL3/DB2sJytlWNyvX6cuPHu5bWUhHHTLAJLX0ZP6wGbWIlm0wFo/MBe5Sv116U3S/leh3lJAVBxscSaUmaiWWZYo61G1jrMDNzvQqupxanXNZpCeLeMz41WwNxym899xvRi3Qu8oBkL/BSpeOMUOuHmKljlRKTzEkqYnca4amw2xEnJQpDuQB7hPD1OuIkNUYAeSsf6BzmL7nMX97u9FSBQY3KkbAHWe33pPmicsK4NF4Vg7sm+LqmdkGeJfZVc7hydNsrgF0FNy7nzohUVNToMGRKFCW6VjIuTU09l1z5IWaaQT908yIYNDdCvGe1xeIDTjRLutlEfS8UA2DwDWRn2MIyixeCweU/9cdpzG8NJlIvmiOcXYU0atntalmcbgCM4su/BYq4akXBWvJKJZwgC68lzkh0I2BFMSfVBH8EUEMqpCfE3ncgFQAxx9m2Vc5AMJGptc5hrXOz1lljKdUEtufN3D3fa+bXalxIZRg27yQ/pQst/cjiW9vSwx2by0inVvGSXf2R11wHaRop/z+aXhEQ2afhzmpAWksGpUtuQL9xJRNqYaVVI59yl7boa1yu/lBACRRA9m+z9tQn80GPdsWtC1yaqvpdujUHc3uOtD0SDfbvh84AJJK92W1/mvDPz3P+xE+ngy5zd52vAEkXOOQgQnLrTuMbsLCpxe/XIhKnAdBVak5eCRRGtPeJLlIwV4KHSOrgHvNe0zPbG7jWYEBoFGntNIvqZJ/vw+2OTnfgOXhvXxlBY1y1NmtyeGW2I++8uSYP63XU/gIAv/2VvCDrOQu2MpTy5I7dH2rHzdx1mpc6AgjD9nL1fbTlrUam0LRE6C5C3A2Gz3l++kgimy1TkWjpZw+gt9waW/vS93K9JycgdmNezcv3/TItpMd6WnSSjNNkdtGRTcuQMS23rzcT2j6qOrXQPj7Zxk1HJU3jsgsxvHJJO49WqyyV4qF3dG5H2LgMaP3iKVNPdwsR1mURXD4s3SFcc3iOLaI1rnWYH6SATap1CcO8Jv9qikS38Dr1S9IIKH2GR2bGMF1riQad2ycjAdWULIbQRteQMqkP39H5tWVxbUP5J/K4chO9Yc428uY25s425ltpCJO+2CUilBxoS7Tq9mTNRn9Wgqqr3WZDnHAbbsNKqZ1u8d6e/QEheB1TF/NCMRDaZbOvVPPUc9kEwVkjr2ia+vo810VbOsRr9kSBt3KgtLtlxQl1EBpz8zjk/qZuwPyE+aYmr+pNOw7MYK/S3z/s1z960fjIyN0baORlltFFknXgkht2BBrpmEB8nXnO4VcHkH0n6LrRLLK0dtqqNLI2SRKuqqto0xkV/ZfUzdXhhL6rW2hupfR1Oy1Gne0ZVtvjkCmOGIy4wTyeE7953yKVgU036Kmt3bT/gWt+SjHfIkwRB1+MuTUmU9sH7xUUPWLTZc63ib9qw3ZtZa833lJgktbuv+5IbVzrVlR2hGxXdMkaEd2V/ABYjFqnNmBDf8Qelp4z3K5pxWzSSiuIfZAJ77b14zfrqLhpE1hcPTdFKnRi6Rry+vU9D0WGyzifYN5KPzUuPcczcFRar8BSGwszQuNy0hihM36maALzzneGZHXy26H2/u6mqCag+5YtkRbFDTlm67FX1sdKvdHSzM9Z/inJ/nFjBdV4RV/9jSbr+MiaZu5u0Og+t0huHayUE3ApSQmPBxNloKoyqbsdW20qxSlmOFcsQG2L/Wp5c4CPpZk0RHJ5yeZ5Y4DbpgRGv43a9ZEag2HQRbQCoXm9rScwwW32tG1lpMWurNXao6mA6hKns/yzxv+vabnMZ41exUlTBlC0bb9bkGdjgHD/tvSfsPS0lh+8cadrvxBdWXAILO9kOVvYREt0thc0SJ8ibVru0vNOYovhVk92UIsq3g3QsNLCE+xStPRppYTT6uenPC+Lkicro00ojEZRMALcPAOmeAUHk/ICLErcN3RmAh9rTR6gOtyOJKXFJWaewahjHVj26makSIW7b76BgPcmM7C17uST0WH/wV1tc71eWwuymEMs25grA1BpHgf80XVoas8Eeic5XTOU7uvkqSYB/mHIxnxNBsP9UFTha3IIhoCwdpftRLMy1eaSeL6WblWSn7vlcWDFWoOb76NXNZp8JZh6JzmM7bpeM57H1+G1rhDQGFZ+h4D//ZJ22KIjJ96BpN1avQUr55ogoG4AsfM00y/j4em2e4a3d05GH2+7odVBkCHjjmmJtddRA8oFuSK4H2lK6VSI84nLD6W+zXkOPFMahukeIR9y7QeTuuaWoxZ7zGy9hkDGUYrW6yhT+DRFmIv7IkrFiVFHZguOaA2KpE9XJNNyXlOg12jaCuc2EcLTlPzA3Xg2G4RXUHbMEF7C0zOG8AyenjKE5/D0hiG8gKd3DOGzVHtXXKTKu8IJqZPWvZe1yXsMC5wZb7VpJ2WdzIRsibJ4Cm6wSbyK+xNj5X5feiROG265K+BplLNg3UNXFkonXesmu1SDsC5zM5mcY6ms5MD5dmA9bGfaDxfas364RTxzLOXOYc5rMrh7cP9QTV1MPsFLhw39lNZoufM0ujXAoK2UdqN9XErCy8bwSV1dtf8dRAKqB/05ry9/ZTdA+oRPSVL3CV+RxPUJX/o1Ll7OilGxXkdSClyt11EFTyn5TKNUYuoZWeRRht/TKEf/DUEP2txsv4+P7bThY7t0fWxXdR9bHWuhEcqgajjZVtbJtjBOtjKwgPZjVRdXrtw4UumoMdvc0Lf1iS80e68EZjZKTdoSNtBGj5sKwBgh5milZUMv04iZsEwAPZDYQA/f2MibAjCWt/0eexKql/BLt6ci1mlnjp+u0TDYxNTcTJHVqUuqp+aF6tE82syVC5aExeCpAwd90iuqT8WUp59o9MwdpmNDmltfUVR3FS09V1E+IWmvYqZJGWDVBgJ1bPKf1ZHCtf1H33trG90fPNh3F5M7JN51XGjsjjt7xLDeCr0D1lWkPt6GTU1e8xlJ6z4jvOEzwqMjjb/yNr+R+nvs/GzxH7miuvuz1ZckU74kKcIV6Y+qhylETMviakKcbysrVeN1f5LM+JPsXlJwKtGa7MYeGCcT415iPSvAx8QJnZT+jZ0QNBVvcYO6aj/a6lyxJ9f45Br7Yhmg6+8No+cRd12kuOsilYGLlGj9c0rcGO5H3oKm88iwKtJoZAtDc9/ERDRbJZ03Fek5MkEToRWbWjIj3PplZoSQRQos0V60V67XTvwyzzEWIVyG4cBpkwGfSTQcISfUHh1VI0nuo5rj5zTV+5Sl0ds0qgA3qT1cmZfmjXU+hhrLdNhQG1U7oqCqhmepEzW12hH8TVafp0O4COo6C7S1EV3DddJamE7/yBtTPUul4+uFqcShhoVF6eEasbEdhxfCwhbXwl0g5SVryLIXYrhFi1YmWa+jhFxq1mr4XgyhQBtcKTWP89GEJAgnhg3bbBiZAgUClrWVOCQ6liE+dKBE+utLacmUpNI8QgsmgLNU0Ig/p2Zg0z1CPqfrdU7E3/F0qL7TLh3tDbhk6tvUExnK7ES8JfafB+Q2bxIndMQ9AoajEbKGc6Nm5IpHaSPMoqRAPCVZppVk9eu/PpT9MPMCOmc2oLN0TtZbETMbvYHL4NMTkuM7+4f7953OU5Ku15cb5dXfHmSc+WGv+QSN0nrzPpMko5B/Y1GFcwhZve+ErDYCnB09kBynTvSP1DMDdAwdwxK5vLpRRWJO+oZVbwkMIgOCpG440L0sDFO1rmUYvkshVIEpwYKiw31CotSxmwwhd1DeJakTrhGNMoETM71JAl4zJ7Rj5tQdoaxX5yFE9xEnT1MIBFFijhC2sUudS/dp2hYVxYspOcofkm1hJd0VcdW4+WSkp80aC8HkQtSm3BKy5V1aj4OhcnNACBlLIxjdq7hvHoOXk5NZQ+rYBv3D+3fu3RXDgcQjdwb7ENw97bEFqKMMr5SWEcL7/Qf3BndAYlevoRI9RAgfDh4cHvQPTZv37t732xTnTTV4/+D+/bv9+16DYJ5iWtNiH1nBSG4iL0T7Bx/9uC50eSdlHYZ43W3OhFOS4eHi3PL//z18rhfq7+8wuk3Gtcb6Xm4avG/f5X0vNy6r279h1D6f0W0N2HSZzoYlnqdZSfnL2XAJWiPTC99sZ3hfp3UxuT41/jKMbIx0CH0+stYSnlH1yHE8cY207XllbhhYidAIh4N7996gf//+3cMwqp9epBHPnYO79+/1Hwz2DWILo1Tmhu/p6YclgiBGtdIQUuDkSBzHpykvLyKE96KBbSjvuuf/oWtOEYZmbB6u9Mbj2J6vGwh0A4LUw/3BvXv798MazgeML5eiGZDawWkj28KNlqhl5nVs5+RB8tjhb3VCAigMaZNnA4CpyIHpPDLrVPoSYiMGULCRk1ein9QRCzjP3k5glfwfgxuBwrktZIUh2YC4sUtVOtwBdLol7LffDbVkChqxHqcFLaPcEv8ZUfUN1YArwSjIMMqZG0ZZkadZXEzwtBZlMek52NBwk1OiEt7Xgi4SJjrpb3icWIkLmW6qMBTgWqbziyOVDqiIXDz9yuO9bDLmcpQ+JAwCO5iIyxaq0gnkc/SxXcx76WxiQy9VYZhLHP+7vN4rhLBDK2QN9gKIvHphC84R1LU6veJEO79UWBygMGUEt0iRINdsIQwjCX/dAU498kV6zaRd4hY6cbazWpzthBS7XXpkFPPEjWKuJPVJPJ3gJanyaIVGyzBcyhg+r9Johft41QajIKOWYuJiu0NOOo9mTgT1WaPvOZnF08noVRrNcR/Pt/a0uXpZ92rLWl85my3bRosyRIMBIoYa4b0tD3p1+o9+k1ve9VFd+tKsbvhcX+ZyRUj1WmDrF43alqu0Ia5qFJSNZcjD8FzF96sFrRe70x4f43lDPu3GAi0FYtPcA94RG0fhAhank1Eel3E2mRDjH1LXSzvXvGmPWVe1nSzLiMd5XUGVGl1UXVGVXkM79d9JSZaKkLx7+H1UJtegG3cqTRxKkjeUJhz9TWKyVUMS9TH1BA/f0uvs/62BgIBBHQI4+HjV9l32u2Xrr9ZNCkbif0Rftv9/avPL6+39/Zvs++WKU7l8/cnmWiqyxz7Cwn40SJK7JqCsJzrpyT6Qktg6GE4ilFRQEK65JvgTXlq75yF3+v/ZU9FFWwLLo64O/egED2oVLvQF5sMZ6eOK9AX5hhPpiTKVf1aCqluKf2ayYE76o7k1cpxrjLYgZTwHwmhhcT6Z44WiVUmCF55UiOR44aq7SIoXXlIeMsXZmiwkxYEL8VgPMb7QhJQcwxkxBaOzusCUJONkmzB1qO4J5X4t4yCeeZJY0mjQWZtFG5UHI74GoQfc0Z9plOAFLu3N0SVmvTRhIgizRU0zifemYXgQLgyZPyMLhPf7+/uHuhBdrtbraEX2+njrChB/BbbWQ04T3vJs/wIA/4KA4wJISvWwRn2iFI4Lk/fpYvsmxT/waGFVuSANRhOyGEbL9Tpa+tPzxnbduW2b3LaeEb4IQ6e9RuggsoDNTcZR4jlna6BOGrJC910LIt15CMKwFQ63NnQd2ETDyg5p4ZC2P/VRQhb4YxotECQNWCArVx8lYTgnhCQOU5t4UlI4r6ck0RzxaRhGp94auSuGT9vn0Do1hKckSsgpCsOPaZSgceKhlWFiyCQV1lLfuUoeMcyw9vCVvyvcXJhhYcRqwDoMy2beW7Ze/8nraW85FLpByd2IAJ6BThkzG5bKz4QI/Im++HSgdokY5K8UN2PYDWfORfLR9WbRWSjlKQxD6c1OqJfkyH77Z41qLy0ENtVp4krQ4bvaAuttddE5li462o+toxssOudpucyrElx1ik7CKWRnSbIsPwczX+iypa8wNIxs22s1/asG9Copyo6AEOkqlM87iRlbZ5qwH0uZt1czwuC1WOBOUlq3IudcBHsBIAmJso24RubJi8TVrly6ELpyaOKPRWi3DSyqlWJUOnB+ojbFcD7Xif6LTs47CfjX7B6ttJ8Bagn2tS71CsNoj8rMfmDKZgDr6gkoqqsDyG33qGfmoF052BZp2NVwB7Em3HHApspxlPmqk9EzmslXV+6tq6Ux8dfG1KlJnRpDdmsg19i8f0hycbba9T4/5VdOxlYWSwdwm9FkVnTyqixSCcVKrbtzLhYH/NZQB/0b3OHyvMSWJMY+rftLGuXYkS0KSvePNMoRdgQkP9Swi2jXbdIGyCzdhjlmmEFzfqDPX+sDxSlpsX5wk0vYuCAmLHnN1V8HAVSlEYRHr1XFdkFysQ7byQTPVvPfLZY3lrXMPUkVwhnJew7eH7s1nXIVOl/dezM6H+aGM8Qt0XQUx+TqNoYcT13O08zCXp/FMMXSsXJwAHfokGK9GsMSG/3w0B2le4kh7FjDDTOcstQwow7s/WIgxIElUgJkwQiJYxr3R2qcBEeQ+Bb8B3bl/W0K12vys5qKGuTlEhFoec8WFYZSBYFKtk01mmvbHV9Mbg3u0lruBanmVzlJUoQLRxlhvIRTVxmRkNM8SrdY/4wKG+DyifsGPKUSXKHNG5nFM8WVAL5LP1tqVUvhUviwVc+01XQXBu/7FKm0qxsreE4dCwmvTQKR/1KcoXoCRKJ49dR7cWewP7TWh9ZozpjERRnhcT5B6zV4s6TamyXKHBuaJ3KcGz/09d2hW+erquNXObh/6HThNXqsG8WSTzJz/iWVMt30KnMSnBkhq/Pop31U07+rJj/Yvy9GLQ2H1bK79fXlrmrrm3QojedeMj/rwwu95FjD8AZknNmmyCKKq6z3xPj/gn8rwkvxQkD4/t07D/bx/t37hwd3Du/cxa5kl2ZArYp/8WPeq5PaEcUDhBPdhRcLxfnAoGuoXmypTk10mAf37AhKGIFJ1T6ObLV9/cma7EM0ZVV+gF9zULjt37mL8K7B92uDN5Fi1PLoTcBGvYmVa1NJoI/9O3fxncE+GoFpjbKXWEflWFlaCOqxdR36tXWo92w23OsaQzfKigLSG7/WZhz37t5HaKyMMaBbnfZdH2Bnff3Flst17+59LM6ms/ssa3gjmCyeloeBUOVNO2I/8ef1M69f3ZJ0BSkbUpoZ2RuYpGc/9cPwnU64zBAIaPb6CC9/GpgXAzBUMS/2zYt9nLsvDsyLA5y6Lw7Ni0OcuS/umBd3cOW+uGte3MWF++KeeXEPJ+6L++bFfTx1XzwwLx7glX0x22xduZoC6rorDUJIu9x4ToxuL51Hc7HSzFvpJQxkLlaaeSutX+ybF2ql9YsD80KttH5xaF6oldYv7pgXaqX1i7vmhVpp/eKeeaFWWr+4b16oldYvHpgXaqXli6WRwLoC5xEsSLTokp/TiOEZGF7LxVCFHEPqRbUQqjDHM7CWlougClM8iw9k4aEpzPAsPpSFd0xhhWfxHVl41xQWeBbflYX3TGGCZ/E9WXjfFE7xLL4vCx+YwhWexQ8mKkrmGXm1Rb0JMUL8JEHSq/gML4widnkVVMob+oaQ2dB14hlZ2qt4DjJinWryrIkyTDIbsWWlB8NzstfHCwJmp0vlq7VACJ+JjSw9qK5XHWCuqu6bqgrO61X3ca6qHpiqCvLrVQ9wqqoemqrqLNSrHuJMVb1jqqrTUa96B1eq6l1TVZ2XetW7uFBV75mq6gTVq97Diap631RVZ6pe9T6eqqoPTFV1yupVH+AVVF2E4QyMA7XNyQLhu3fuHNy1Yoa/9OVcevZU8jNt3Xh3f3DoCE/Ey6c53MYRwvOrALaNoPvbVxjcXXhOlrsR62wbYp1tQ6yzbYh1tg2xzrYh1tk2xDrbhlhn2xDrbBtiVVeYRqzPG+f7bCuL5pMTB/vDM4d9XxrGXWLns7g/IUyj5bN4MCFc4+OzeH9Cco2Iz+KDCUk1Bj6LDyck06j3LL4zIZXGuWfx3QkpNLI9i++BUb/Esmfx/QmZavR6Fj+YkJXHHtw9HJ6Ry40Z3jLua2NzZ5jLeKBLneEu431jmG6HvYwPdKkz/GV8qEudaSzjO7rUmc4yvqtLnWkt43u61JneMr6vS51pLuMHutSfrjgsUj1lEkTNLXNNLnolT1gxz/lpxGr8pf+W13Lr197Wcu8fNt/X2dS2Gjjz96q9Dq68Wve21cJFLWXf1no48Wo+2FUTT2vpoHZXxiu02Syk+xk507f0LtrRS9MeVIzTZLpMPmU0kB5yrUzCsG628/e4ANfcY2/QZt2jKOEcM8Hgg93/Xt/69W208n8XBez24qDmXHQp7ZRMl2m3ixTmSmVKKjD0FF1aq/yMBAHIrFo+ziR5GKcTzCGjVeZTkV2dIPLGVFeFM8f8zZv3DhrLnXuTqsoJt1RVKtZDixmU956ZW9XtInWLV5jFFSxMKi7yTF7k3LwB0ZF2VwvD3LvSs+te6fmuKz33rvTUX41rX+DfHy6a91p1/XutIqx2c4jhVeL2aBlNFQv40ldJnE7a0HBCWNyf4ClhvQIyUg3QqCKJRR/K5TLBRTRFaJMpxFE1Ae1qNOEIGEA2c+n4AIhVOlQKl+eexasO8uVJeJmW8HLlnFPEbCLb4K7wNVduYWin9WqOrImyWMfcXUe1c7lYQeMsdrCP0zzKMEUbaf/dJwT6tip0AQCsS7hnnWpXIG+KWAqNP28sYtkiGBmBMIRbSlIKQbilIKXwg1vKUQo9uKUYpbCDW0pRCjm4pRClcINbylAKNbilCKUwg1tKUAoxuKUA6xeJXYrGReLHDWBuvADVIMcs5hPdJsJ7A7vsaWY84Rq+BsrNQKr2fuY2sivEJVNWgPXzG0iNZdDV9vnprBuAehxaC7ZUUC+1HYB27bOxLzMVpHcPwnmbGqJISy6Vi5QVKJoCkBbqvIJexANUj+PnRoR2YvrVwiRMIjTaq4UPHtw1w1InuQJXHTcBSrn93LEwjCCLILNh89G2CMxURuOhyNFLutH9wnBbGK66rTlW+MRFIa4TApuMjDf2uL2zSOMUX0s13L/qu1fed+IiR0OrzOda8WG159wYiHxTn9p8TrAaSr/W7C9CVkY+2L8vPeSrrDX8Z0zrSgLSn5CgVhZgqOjHRB+Iel5RW7W3fn6O/cZHfgWnCSMdJwf6I1PUVq3W02Hjo7aedFimOxMSqOcA0010uXEj12VRPWivp/NjLVeXRlHe1eUENtHKST4ZmXZ0Au1pJsGM1zVOJRqKy8b5wL9zeJfkW+6cpH0ORuf3D+fgNpXX/FZU8nt+RUKajPRH2UOdz2OUdbtomkVpnE1wqczdpJWL6ebak5/WJg+HQ1NdpaKyGtopWGuBgUEMM9iHXyFDY1CQDe+C++uqVbHlg5qvLb2ist+rgK5mf2V7iwbSt4683DbyLYfkin6uHHmjv+bI1akbwq1X781HQ0MwL3D2VTV5qYAbq4NqKywza4/S5gAf1v0jQ4asvXbLDaKIxO1ubBAvzXrC60fjddRmiZC5RIVN0wzukb4UYjAEIiYT1PjU83n3frP1uukdJZ25MrI3sJht7lGi5lr4IY3OMvBcz/24EE8YAkoMc5w6y7yoNaPI5ua3FVHtQlbNTHB80FxB3mcRN5zhb1n0IVMEGP4hlQZIsSAN04nT7VnWtN6pRcL4wBHO6oXT0rqBq/AXwxLrKkOKFbkiCCAJeBzrtLhHHKw7c1wkLC3Tb5QPU1wzWBoya4nD6tZLxqIKYcp5zl+ArSkfuo4PF1nd3ut9FrH25flNL48UhXB3gU6ddrTbGnmSqZzu25Ow1qyv12voHnv9/ur2y/x+PzX7NdFfm9HEmyV7A8wcva5ghU6yXpF+o+PLZVIcnVHOU2kIvEyKp3TF6TQp6cy+YJuhDNOp4ky2hWuUV9yJXA6q5jo6uH/Y10aUYcjBgGmvjxlh6zVEdVJ9PabL5CzNOYIgnTK4Zns/51mzGCA2b+T+19l0XzICudKu7nuD8LWXBAHdKCjz9io2w7rb4jjaFQu8EcqzdGlrG6qznADVz01itf6DuzplsNoCDW6j3FYktw7uHxqifK1ICxVeiyzyKJcRuXSELpLLv2AJei5h5qe+a9p3DJut9guN2janVNdFCjFC+Y5dQvp8qqCAXAc6VOON2FhMdNhHMkrgIo9UdnoVPVDnrE+l31djOTcjtwx8n3MVFFaWPb74lV7EP/CIownJNxtgDgjtKXP7qBl/9k++QQhTNKSbiCPp43siLYxeJyt8bh+fmEd7Y3wF5lScRntoMEXYRlklOsqqeivuWHior2MYbv9ox5qH4Xm9dyd6oUfpnebRqVjxWi7qHXmopWXeE9WBZyv6LItg4pCKNEL43D4+MY9OrD/NxTvYS0e7oqMm5rMHK56IEw8+hECA060EOLUE+ECT3RBGLEeYhSGgMlN8kgE453XsLrCMymrv0iFMRZnSOGGj+HsIC601a2Y+V4PcaEfkfpDGxMzJdOEkl6m7GZfdwYjVF8Xj6F2h4KAW0w0YN7EuNVmhvfRwqhFSrhFSuhUhKbNBnBuElKrzrRARSTVC2rgR/3ZKAKXXfS05jL6/xZezLV/i/f3DcKa4SClvRj3P2tCM4PPfHkH+nUZwlDmCCElaeCnhcJlpCsOlLd42P/PzsWHa+t2jtu6A9cCZ+4GY+psMP83wuwx/2Co1Uanz+xMSyEcpT/CT2g0mJPBKZKVacrl90UaLIEWH+z6AVrRsIqauexKIOZzfTeHFa4URn2aE4ncZKZ34K00yTdVWpJ7TsApk4pZsJf9eWUGrK8CUwtWPPPqQxW8ye9ihz58zMJBEqp+G3abvuOV61cYTnJKDUfow4YsKfGtcEX4ep7cOJsS8Eyxak29jE5fWLMcvgMsCvmL43D5j6WJjAo7YkTMkQT9zQT/zwje4h8C7s37/G8v1pW25DI/xv2OxDmoL9eWfLtQLn5tnWT1yqwTGCebIEGYDUKPwuD8ZcimlEjto9GtWRnW5URKopiol05dL5ehZ4myCE5LH2WR0P6xsiKg4mpGqHtMPB2xxi9O54CFvBd1oRmY9TldZMqXR7fiH/3tye4GDkwCZwm8ZdrNgmGTn8QRLyruxfyC5j0t39wzODm4FXRoPJr0yf5WfU/4kKSBIPUIT8jiLEqSDSZoItisps5tuj4aSzqOp57JoBCfLTso6KZLu8lFC0ng5QWNfbW3TwqzwEifgz6Nf1xPHiHtFyv/aVN8rHOgtIUH3l+OjN70CnPPT+UWkeNR9HSd25sQvcYAp3wVJ8OG3jNyO4ke3/pyg2wuLXB/DpVLyC8Net8QIUOrVPj7oC6J7mpTTpb1NgvjZu3dH7yadZ1+ndCUDwi/TjHZKfpGyRafMOwXlaZKl3yikW4TzEbhhCrIGiQQEUiO813a1hzkYJsooN4DuPtfoPj9jvY1+8F0GdPCPBiNa/ZjdKPGgjaRQqhTTkP6k9or0ka3+lM7rVFItm5eqhTmhggGWnqY6gqgXvz2dR3tS+jjaY2HIxcsCgqs4MVKdDIlM5y2ELFn8BjmVaXbEn+SnK/Hh1jQlOnukbN/JkbjVIUbl4xdL+l0yq2iB3NYh8nTLEL9zZpfdqVzc1bQL8j+XarrW//fLOK0ZoveCCWrJv61vpJFOQiPX3jKybTDTHYzKh+1vnEIneoGTZc7ZbP/MSXduZvyNNTtb43Rx2SWsJfDq98kLbgPqbFuqy01tqS7/zLZAMKaWYf4/t5C14YGgp76G33cRay7CitjYtqB1+cmIysDSFI2QEx3UZr2C32PXH7UQtR2UJmMQRY2TZUUThpLRjpiGVP0eMCQafpPPtqezUolo1b2iqOgkr6ezVe/RUL/6O0jSy3SYL8DdvV1oJegoQZzKCFwN4tSJxGXJ03wyap1MpAD+TIEn9q9Sd7Oisg7LmLWeCR0RaluqqlsDJWwjJQjYDkIrW9OngXW7RgqzgRTUOCO3BqOyTfIlfaBl9W43I4SkYmK0B0of5OY0KIHeBFpz+CffIJw9TMF1j7am0RU04Acp0ExZKrpTcs3OLJ2B9dE0yTKoluWLBeQMx6oxkzmwiASPVE/R92fWsLQStHzpZBpCkFhOxVV0X8SeCOC3hgbrTYZT8jTDGXmXQab+NxmhI81VyXGJ6nqJn2Ykxe8ykuE3GclxZenmdB5VZUTRer33NFNsss4+7O+vPrIdbceaz2XMhvU6osRGcHCpdYTwFym3EotD8Q+ZH4da/L40Y4QYAB+zCMRFCnmIOf26lfS8Vm5iX2fYnvNa9PxvhaBrSXEdn9MS1VKRfaKLlDUS45sG4HU9iS4URrWGKJttb4ayWb0Rymb1Js6XlMmxpmzxNGde6kmXxjGNNL4YX/E+QsO3PD9NC6pzf8uIYyq72r+vv08Sdc6SMqnluRVFbZvomH95SNMzpvuLQUMljWiPJWV6BhpntIleMbCJ25rUtr68rrFZPSt1S+LA1o/r+3N1NutdCazhDHEiDoyKS6TMhuh55zWLmOTNORrlID8gFP/OotzJuNQyFpVl+oY5qUHrCePQbYfh7ywSA/nAIiXJZOh6+ah3dQihCP9ub05cwta1BojAXPwtkWAmeRgyF7W9ZmHIIOOtzKtch556+u169lmbIHpLlmA5glyOAKfir4wem4chr4+E+ymnU5zXx+O9py35i50s0f9kRbxk0/VBuC/bkgDvShLfBghtOeK3wsPrXfDgislI3RBcHyZYglEehnl93lHeS/TnRczHvBsMg245LMG7bGc+Z5W4rGUvrsojLYfDW8Ah4u5w2Jg5wwFrmKuyRzfBQ+d23g4bAiYaABGx3lR8BiwP+B7uSBndCpD/vNPBFjDcnou6LQn1NcGgEJ9Cv20b76Sr3rLp7fmvr7HhTsdbt9jNlt2Y9NY86NfofCW/TbfPfGfu9C0J4tN5FEj5sk0nS5vjUZ8bow1x2H2AkSyNvPfgWVDtn5LpZ1JK5sKq3q+bP95GVmrTWm5Nzl+nFhj9Wh6nn7KULa5ux6ncaEjL6Nvp191pyQVx9ouvfbXhYSIP9iksnUzXK2WQRlXdc7KElzjflhM8751oQ0BrJkI4zo2rU1SC7KNBG2wh7KT7xixDl7OM7PVHSlzBIjS+9M0/h68zrIj2PJeBnBa65JljHz280KVerKjhqS5+oybwjs6HnzKcK/MtbdM3/GrL/BaOMwzGK9ZS7Fkmg1EbO1+od6RKjZYaSt9mWBGP8PORHo7rNzPcyr98VAa7XozOv7JmeM9XWT225+/ZZlhfS2f9N/VVnbeu6m9p66r+mrasapE2V/VPvmVV/+T1VRUlzVUtW1eV+quafYdVbd4chmWpKfadu6CxD+38dbvKXmqHX2bDz+AsV9/AK5syXGytoU0znBuhtQJsHLg0ABBaK7BVXIgw1dxC3B6ojdC2UlvZAR5T1SkTFesARWijyK1W7761HAbgwZ7o3SuAKg1gJLSl0FT1IJTUrVh0VQdsCXV/iZeKA39KV+Qoxa0+dmah3EJR1TV68Uxg2sJ8EdooakbkMpV0QbsDGnmdbjYRajHZkyUQbKI35/mpa3EsaH7vjbY4xRxSlbqpy+rmnAjCuDWMPHOtzjexlI3NHU6LdxACsicfTPz9Ylhi1fOQYb/BId9swD4S0tA3L0Drqd0G0fIze79iul6/or03v796pXLmt9y1gJXKTfRn6Ugd/zBSR7pHyjAsq8i1u6SVxBBSJUvhvevjUVZSWFMLyvro+PjZu/cvj950QL8+7ARdKnX5rCKDu5hXpI/zigxwWpF9nFXkAFcVOcRFRe7gpCJ38bQi9/CqIvfxsiIP8Kwigz6eV2QwwIuKDA7tFM4qM4VeUsupB/aVU/n7RZ5/LtbrWgGJJwgpOhE3G0C1MpU4Lwyjf9CwagRh+wkUNRqypddozdmWi/qS6JSAsB5nKT23XZlfbV3o75Bb4K3BDRtzp36mf/vf756024jrbWFmrKxAerlOZQhzVsjQ9uQW1PoxX7peFab9wd2QxlU1CcPopIpoPK0muOylLJXbjkuJnOUPhrCsTG4N7jnNnVR1JpKPyyETTOR5FfkpWM6rusKkZsNL9lEZs+5gImlxGpcxm0zQJqiY1HfNrIk3WzylZ69BhBk57w07dZ6yWX4ehvLvet1Wp6DZPAzFv+3vF1n+KcnCUP6VyPuJOPFfxRE/rkjAFsp77VER2IP8rLKczt6e5rYAbbyvyKUvXm8nYWb5FBRcGych9Uu1foDLgmKZV9kMYmwnWUZnEGO9k0Co6ABhgQ97Mkg6aAVL94ukE3RbmLIBIXQcqBmlOQuGfSgx3pbBcB8KwOZjeADPWrs6DB5W7DPLz9lPwSYqXZj+7KyHDKvUSwsZXomiMY37k6ETq/6oUvqZfQhob+fgxHtIysT4mcRpNRnDv3FRTaT2xBCC8mvBX44pHMrYLZOO4+obaxzsDldXB2X1+HMVNYY1luMZyvZR7H2hekC1Lh7pOd4aOK1B3TDcPe94UekrHD4ux6Jp1XtcTnqzC5acptNXZtdEQxvttSqb9XXan6uI6eVhek3U76LS5swVZEvVM3ha1RzlRc3RPtj126GPkHNOBdzGeTXBAShanyalTiYRIFySiBJ4jaAlzYnYz19WUYkPEPZbLGFRcCDAHh5FW04O3Mr17hM8AB0/E1f/uPQlx7LGkPmlHOd4r4+GA+9DV9orMN+wLh0e7ivPK2es5tGYHz61ypZuF5ee8oW75+eDDy0xryYSuqRW2rFYG+nNqFeaWLcssUhj+WdYtkOL1EZZ6+/KEU+OdCIjueVIwitzD8QjQXupQyF21IFS8dOxHdcTg+EaOPcjRegpwYQymrBqZbM5br1Obg3khaLlbObiEHfKOBIoKZaXzQQpnZnaROAHXinJWySqYxqvqglU359MsPh7MEEY2h8GrDr9RHm9g779aDJBERpCbhB1r+nWROcj+ElU2rISNX0bMZOzH6ncgzLbxx6JSsK86x/JS1fe5AgaiziJGCmR+D4MGSziKl3Rp43PBCBjiVGgVjoLQwHw8VyGYroOKAswFvWtKlARy5jD31cV/r3CLyr8vMLfKvy4wj9X+EuFP1b4z4oEJyds8SIvylcClE5OAvxbRVr1rviHisR93J/gXys3i1uFevM0y1Slf0OC018qstd3+AQXlsmXSp+Lj5U4sHLtvqlnXk3wz/A8AItLoICQaJGG4bdKpjx9r+KTvE2KAr9SX86rCVYAGobRi4qU+HkFWoIvFaH4saqWiWoOk1Ioqe56Hf27Wq9PquijWChLjeoflrTEP1eiUUWb3dXPa8GdfKnipJqQWwMMs5Yqa8vyFBG6FN18qqIvsB+iqXZvsg+iClIASMpRSeDCRZDzQh64h6wyaWjK+Ek1cQIwlcouhsVfq0lbDAhRHvMJTkkuL3cfyaewFcF7yPBxWhUlEDFZloPraYBwWkQ5lrXSeFlN8D7agGbeXUWXqXF+19aybV/JLwBKrIi+Vb1lXpSPlfWwv14GK1Hdtk5wVHd49V9b63uyb+NL+HXicjKiPZtCBbCJV+MdnXOqKP/6t93BRCzIt2rbgBsjdIc0KwSyFGhQNhTB4ml23A37XWxt9VvlDF7F0KEe6a9tuAXCzQUSmoxyb7HD0P8dcUwBibqWNbxwL3x5uONSIBmbhWT/zlolJbk1cIoZ/lKF4ZcqnlUTTHG+Xtt3qqJzd+VFW7iC59X4RTV8UYXhoyp6USFckSwMZQYEQsiXapzJm1IlgyTR82r8WH7xooIATwJe1mv4Sv10HuWVHiGV9G+PpHja0Oe5YRgu5d025JDYYfhFpsZ6qcMUsLH219QFYlhwdedY9TlMsTPkVoLBZt3sY7GQyThVEwSrDUm3rNdAHqKpXAESpWM4sjAAqI7W62URlZg6uyI3TvpuqETEtMsqF0OcFNFKcmdLgDOBQNJ59KWKVxMyxaufTHRc7ZS4FG+gqxUsl+4knUd7z2ErdOLhF5Uc7WgOHAOZ4bmmmbwVCMOo/YX6DG02et6icyx6iR5X0kU3knhT9yU3GQDCwI1cPFMD+AK4WtxPiOoCyfxUhET7YYnCMNFhcVN32SQALQQVB/IwS5bHL46O35+8OXr6bNJRXCPLVZKsT5SyDtgMgjeJwL7QBJniX8ScFmZLzWg0O/aiIlN5D+KpE1GtqIkQcEqeVzgjLypN5xHN++RiqOp5KZ73bIAwtCgi+0o5+5T84lL2+EKtdU7EZSi5BopwUkQI20YijhnC+yEfi+txqNoTM9pyKWzmKUuy7OKSiitI0gkcITHNVPRpeVEnNlt9xmJIJaYITBp/r7T9nH6KEObjCEbKowryIjOExQDREAiFyLvCb3bhIXGt/VAhPCuiPmaVYDzUlH6vpAme/BshLOboItuqcKUHkj4aHwz3gdgrClhwS3qJCVyqUiesUgvC7rQSm6CX6HbxZTobUpuUpgTMBkHyhjlmFlEJJPZrpRynELbM0PDWQGfiOy4TbrPnzpxUgJA6tb7nw70+NhIylVXJrKbOsmQX3St5UqtoiDr7s17FJe5Vgqca7a56kGyR/OFekd4AdCJEPxmU7kpP/R1dpEXJL4YtcRXYmEVoyGAUu+rxMY/QkOOp1KXJRIxFPTPvSpG7zmZ/KqJbA4R/r5RVL4NMTduD3+Skyd8JNp2jMW8xoirRkMsgiscqEo8oAq8pZxB7LdnZjLSuE3Sjlj4DwbfING0gh9ORfgBvzvOKzYbB0KmUFh1Ov1Qpp7NhgLpBJxbtNlYSeDdxRSendL1mw0bPbMyGEkOycRAMg6DLUDeYBEbr4qRpWxatcZraz5qSSlyKfoY6tIhOKN7HZbKQea5xUpa8GHIsiPFMlCmAUlfESwapnZVPZOr90nmf1c9SBgBLMbMpy8SZdVObDXPcdsnq41Im0yVVHxTlRZayhT6+JqW0Em7WoXHWCo2lpCsEpwjRZzxxFGuKo5gSRxlt1Y9FZ2l2Xd2lcI8mrPNK37edpJQj7wWyP05kQ6N5EXEUhndDrkT1/vAo/lghfFpALr2PVUwnrtxo7qLn+4RE9xUL6wTdKtri8Vjk0AjIIzkT/VpwBZycFxFDNZaN1xeiuQyCh1Pz7pS5WZAA4UxM6Ey0ipl735zBaGsiRdfHzvV3OheVgYAalYJwGCHBteZWtuiICS8KK2mC70btUsabzwa2V9uV9QLYLNVa6fmlnxa+WZoSVOBcCn+ANdZ3HiQRNLceUA1AHRhGQBEXZRgOtJKnjAaYo02UyUC+aQSXtyYksK+FELOO9kGIlEH8GkvkcHdDPhWuWhW0cuRL1WjtJxKVYy0oGPaRJDdlzkr6dQXR/1SizqRzlmTprDOT6zajXwMZiHe9/lK5iqctPf+RGYkEBvdPmReTdoNGTyW4t1A2g4ywnHci+R2E2pWP3QAFrgarHf5kwylbdAwkdhZ5CRLZABmZ7J+tYm3ZRA5uXeJagMS4HQekcQnk1JOC/FY5IZScs33pXObxBBcCBquM8iGVlMHwSSE914+LK32ZT1xn5pNktXpH55Jwtq8N6q29y3SQRadQ53cs25wbTgpamiOlbTdaLBy9QdkWr+MMp0goOtvqC3cg+KQD5UQGPUkceSPHthbnCDDXw8rburFuYTgvIvsKaSfxRsWevNW2vdWhj8FwEe3aJISfVRGoWZxulXS33BIL2YntY2+JSkr+cUFuDUbVSGeplBc2cTlU8MAnhEzRuyrax7ni6JW8HWcIV+0KiDD0P2jXUphmJK+n4kpN0eWW3kZSfFDhJVm1NzneUi6VGSt5J0cJWTqCzPHbKoLfcV/p+cRmZjfuQglqVuoBbfSkBnJSUnLxtIqkVABBNjWlzjNUTVw1iiajN1Xc7RYTUuGEzMczw0rHc08BCv0l5G0VVchy3iQBKZ76ESXkSLxHYXh/8GA/1N3pyCXw+k0VF7duTRAaVWG4l4yMSFA0UJFH0MB6XRFCmKe9qhzd7Hrd3yNkChk39R4irLrfVCQBcZOExD4uG4LNnboyUDyNPPm24L5HmsaB0TjC7Z8Iq8ZlrbGfbg0gTtqHKioRGpYOTEB5qYAC1hupaBDKLXJUhuEeyNDDsNwjhI7QX6IZXJLXShYgfq/XMtZiGELdTUmYimIuhfwH+76xtLH4aJqYYTZihOIWtT8ooNZrqZci8QRttEesxBHKoAThsl0Q4sdON406+jpo3PmtOlEtl6Jfo7bD2rPOmdZpwj8/zzmwxy6K3WvXVlClqNBkn1yrQ6zpP8VZjsyLGrEHGoSA57m+kwKEYT+X1QTJORDyW6X8McQvwSkqTVXUshic0A3CrGduZtfJdwF0LldKK93ib9UGoY17Q9S98cSt0HDGM/dXSG49qLthSPp0+zdrcr/RiROIzPnuQt1d6i6ue/z5ocm2bdi/QTMniFcgvw2RCXq7zWZXD3Im7/MP9YvObX/LXUjbFvI5z08fSWKnsTwOEdQ+ivqHtPYlVa4Iz4ptrgjID/0D2kHt2L1MC2z83ZVvwg6XAqUoNWSVdkRoAUvXhkry4EST0sH7ixXtrJKioDOIxCQJU9MqGGt20rIzy2lhhcM/soWp8pTOf+wo/5mLHriP+2/XazDCRBDH+aiI6u8V5Qy2no9dW8/3DrcWO8FywAwWUQg8e84MPciAwAFUcynGA4ILUDNpfkqKMjbIcoaivZcFnOs5jYJ3R0fvT54cvXn/7I/3J++Pfn32JsCXNproEJBFgLVJbZPIFOR6GX0uENpsEP5sWz5+8uLZ099fPXv3t5rl9EtFi/IRS08T8eY5T04phAWIpOEbdHe0Fe6ccPbb3F+YZfef0jkpsVMgXWKkgRnraZkXKc1jEffFDYgZbC1IIbXkrYAQpTVAbifoSz+gz6oqW6KjqIbeG8xkB92T3/ztgD5e/0podbMBqI+uMYKd3kE1NYnJpSUIKVwRPuaNaOnD9xUuSDaOcnml650RzEBKqlbZanP82s5DbDhar19VaJzWHLVzXBRIySJJUTTfo2Gt6M1xVBQ4R2i4KqIKM0Hd8TDcy+rTeFmg4dciuhrYEZ4SXkSNWRVXTQlPi8jXBVsZc9Lycc7eVsVyfDjcR6NpPKsmhEtfZTlqqTmW7AZe4hn5o4qmSsUo7rt0Hhklj9XxLFt2+jkYHijd1Uirx/Ii6uMDXDpj5UX0qsJRTphViPXY4i1Pz5KSPk3KZL2Ocr+EyFnnmFnd/FM6LzBTNkLwaORMCKn+nOljbg38Qf2XugwBBOiG1t9Wn7J0Gob2WRA9nlEAidkEUq31cct+IZy4YknA5qs2x0rnUvsji6QJDL41wIHtyRHZSUARj/Oc007CLjo6MlzgyXb/yKLnFd7r42DF6VmaV8URf2vcH10hYMfYNG7BJvjPCl+6eGCg4ni/qDaaTfgo1vJLFU+rCflYCXoZ+wpvKfkFkS8p8S+VFhu+8DiyEaQV6z+4E3I09l8R+vDh4HAtdijk68HQXTjxhf1QSuveUSXbXNLOafK1I83eOvm8Yxc2QNjvpNuVbKzJ9aJ3H7yMI4Y2Ht3DHO/uMDyo6btdPsO3I39WRa8qpIyMjEG5Vq6WOrcMISRHMhFGOo9yQshxhXiX7Bv5wU4jt2PHv73bxX1oTmeMiHl3MMEZPOxPcAUPB5MRG7+q6p7xGa5wioa+x/yb40imAsW8Sw4lM17pdttayXFVbyPK1ff7m030wkg+3GVFgprqt6A0HX4ItZw9X6AL7hjafEBQ+4LMfwqsQi5FWy2FrbK+aCkl4Su0iZaeHUpdhCz3GeSvmBOJlMAmMmriTP/U8hYzPXGMj+WJzVl24RjR56wD1TsaiQINHCBcgju40f2u1+4vx+8CRBEsDKNr1mYIR9zxtICq0zbPkT64cyPRQy+HvJW47M1kjkrcWDAQXjRm7tjk0Z9+GhyKtezKcw4xOdgof8gh0JbJhOKYnOWT0VkVpbjEOcIX5ulUP202EXNPP+gbVm24vDQDmZM+XpBlQ2olqMMz0h+d2fN8Joalv7sgZXw2wadS7PhJ/jkh/dHJwwv9wYmex7m4MbvdOT7AF/HJxLndR5/Gn6SFzrmyyzrVT/iTftos5A6cok1aREu8NFYheIUHSP+WXPe+4WP/qKKZoiGUIYWyo5DyfCk0qFOLwFit8BRTXLhJTqMnYPsGEcqsoN0z/lGLiPATYJn+KhF+u53yr1uubecATIzzJ5+AaM9MRlfCcGaGBZmCaqdeJssopFVN1jYDsTO3Bni/TntxBP1IbEBynPXA2lNABqjlWZSKGjVWBGc7OOMWGX1N8CODCei54kB7KnaSjNNkdtGx2gQTCULXbs3aooVhEdo0PlAChfJK8d33HCTAMZX+k69LhB8VRDOcw8clrgr6fCuzCetebGQSkniywW92QZeNyduEq/YQCvEEcx/UVGqXsuf4lbar0HJnHX4Muu9pVKJu8KNVqBXVJ7HEgl75UdcUMPNjL0B4y4DyninFlrhvEJ1qQDUJijz4lj8DkbCKYELK9fqsjKTk4wJyhEiDfcxw/KgwMoDhR9gSiGkx5JsJwjabMqkxSaV4Oa1Jfd5JYRCXZ6bA/P8/Htc+Hh/LWsrSm8pNvLAhbHO98B/OWXtTNN2jxR37pzJKeSrP7qyS9ix7fVzxbBgEG/zOE7pu8IeiJSZeXc5ZpmVGSfBEiSQEqU+z7KJT8awTdJ8WvYpnYFT/+p+Jk05kSpPy7wh/ZNjynZGMFzoGzA2FLSdF9amY8vSTsx/OfNoq2kni0o3Ltcd60ywv6CwMSyAutBgfcrhg5kP1ohHgRlJv4pNlUoABmjJIk/skHhkUm0jAsjvHbK2kI3dRZNd+v8xTtpfosh6+x52ebYQo7/ucIvyXlGO+bT3UgIwgKCFyU4m8co2S6HgL7DtNunE9tAKlJT1Q6fUn05QN/yqcDBmO1LjZhdooOKDewE3zJ2lxPE2yhJM9QYLLxaCus+GL4h+lWVCgFlOjC5vo9KJvIobGtLfKVxEaMp1BnxqrdpXsUY31FdhjqVyPelHHf0LijKFYhrg/sfnWdXolmakKaNPnOxQVjQOOA5Z3VA6HopOyTkG/VJRNadA4+hCpKnh2uiovAH4DfeZlHC0Je0fziLmAihqIotxE8lRYqPpWeO7TZvT2ema9LJ2XEEPrcaFimsJkH19tFLPidJZOnQCe4p9HfNFu1SJWZku0qp7BHTCQn2EgXg9e+zq4Lv55Nx3fEsQKl40wVnYWDOdmChznvWlesZL0d4aqOmGtESxBnqnUxaYDOwzdDTbGOxUT0F9PYCGpJ3MdpwxIfRW8mKJNaSKV2pfqwAI2Okb4y82AVh+9Tl6VgirkgnXZBrKPVOWjqjyavxM1vwv84o9bYc/eAWVeJpkBPPHjYd/B9F+KfwaDfxoYhLYNyP15Q+K+AXBcjZwBXSoBbBf9uQXAiB0bZqTbtWA0Yg9tco0WwMCMkPYKFsHLmVfMrglEtAaIstjlt6IOqX3l4E0VSd9yW5UW4fygEtCLCf2wY8vVQAEvS5qgPbDztTf3V7O5bqtmj3/953vsjVZsdVoAfheX5M12G4Zpvh7gHefdbUfvZUNvr5rahjiaq9Ls0SEE6iDx76LG/pnubVA0biHgF11dQcEvOy4d0agM7Ei/lkf86FNBueDh1E4CTiSlFavB7Nk/A5Q/DKD4nTpd+h0aGPrjKhGTFiXugqO0d1ImqzcCJF5i+UPmCdC/nuh5+q/5et2okYuyRBBMUSrAQ1qLptjpg6EhA12Vec2818oAze9L3UYtPVpAWa9fIpzeDOzF/QnktereuTz18ATfd9ML83qnhzayMXjjgZn/Nw3IvLnGeXbHpJe9ZVg3HpQfRXTHwcc0aWPTa3dBmSD87yK6XCaFlNnsDaQzSx036Qpkr7/BurOhzwDueTV1ioIIbTbICQpUJr6A7rnD8bDEVZ7UuZCfyP5oF+5apSsa0fG3ws1pzByhjYrviIa/tFoVWuT3sYgGAl+w8W9FVKIhTVr4NzV4L00CT25A1eeJj2Lz5BoodjtlL38WecWn/xi7psluOt/tyyDWNPkuiNWl+lOH6k/13HKcSjNg0ncrrNfpTkzG8jKdXzxpnFZLxjQJst3n7Bq04N7ghvwGTKzb9Rb4xphL5STzZxztDa5NitS/7DfpicwH9R8ASgeO70nlHWab177lWIOoea/vUKWtNElROzDFFQemJss24ceT6bQ6rbKkzA2NUlA600domRTH4uc/PEOJOUNOf7Y3ry9zhpLvc4bcGQKlAPMTZ0hPzjtEN5drivZ2izWhyw0u3BrU3iYwiD2l15fDu0Yurd1HzhFCwqJ6wyn5xRt5qkd2x+l1iXb1dZuVOnHPrXvanU2I7LaD0Moc6CvIDxcsmwxB81BOEwdLtLB4Mp7YqyJCQ4fbWyWW21ttPVP/Ywz+Mmln8Je7zsZNGXyesoWNxPQ9OH7RooYGyf1z4oqQRjbw0LjUipthGfP/YBNCr4GZpZC2Dgu4dHoB+fpPfVRLxwnvfnKGNraPQ1tDDxhmkpP+KH/IPNuKbvc/2EjK2iMepxO0obtYztk2aFQ+K/S8M0+kgYyGRuRY8SbVYlkSLuFyvgMuS9dO9J9KIBYG+ozlqVwhGI4BxsVuRH09AacZM8O5me9OoWaN/Skdwjstjst8taIzvb7y+gOMxHxb2qj05qTQUenTF7TerTcViZ9OHEHUIzZ7R6cX08xIqZLZLPomP4A7G+ziHfg4c1iBPyKXdrj4H2MEpkk0QNcm9MV4ThNfV/kpMbbxr5TFR+elF27mpPbFuf0iWa0eJwV9wek8QPjJNiD3Mk8pB82igmsamvpFbejJKkvKec5Pj0uelHRxQUrlnt/+uregpe4/UhfjySdVQCjklF6950mapWxxnCXFMvqaRNz4bTbay9nbfHVcJqXvVsTMcHv0NC2jy4pnQ9ZbJeVSEJd4la/EhS9z/alU8FhGcgBLStCPtRxr0cA12FxD+bGcn8K2RFvGDyOi9exxaaGC7L9NyuWzL1WSvc9JK2zVSM5Aq+yhXURIfRRdan+BzfLbhCenRcTqQzC1SLuesblRrdiOhmEplpeXxccUpjqWCFDmATQKumGpXbk0NOCvSVSi+rBWnK4STp99LSlnSfY7z9q2g4ZhcDvYI4TG/QnsSHA76NKtUNRstZFlZZE3s+PUPIKCbdYsWzqtiqWEXIaDALelQYIs9VDne3futr2t/3nOzxPeTD/YbE3VrCe2gzw7V38tqtU/bbE18KXJHk5yrtRLECdRDDfIsLSyI7aBLtqgfxsIjTUIjYNx0KVDcIz7K0+ZAGUA+toVLx2saS1lOlBJfULKWrmK4EP6NnUuZTN5ToLbAYJcqNg7PrZ4nxA2pl33MA0gDC+UDmlXQDykOmse1RaKkvZO4U6+/a/1f47XP9zWTrWSz1ivTSRCiwFUun12S4wKXInZrcFkPBj2Eerq96yR/fRr4snAFCBGt//zNnTVW5an2Q+3cRBIK9DjGxLhDRLcwJu+LEkJ5mz60gkCbMLGRu4LhnbS5vbmafFrrPfp3lMNNORUepEUS+kV2mAJnZtzW/5OM3b/y8al1bytRg5f0RzXMinMxrvhRIJ/ietGE0n9cQ0Yy9owdqNuOYIniX/A6pcCdexNTL/BvyDFXa07jV63ZnPTIrI66mfdJ0n7LckRGvUJya0Te75tzcSis+R0+2Zb9E+lbXjNSXUr7v/fMgHvCmmbw5X3h2nKuT/Ka98f5mt9f5Sb6CRB+NnfxBjpPGrHFiouAVyqLTXck/mc56dPj15HyEYzaERKe5N3BDh3lpzOOwUte523GRUFyqZVRvipaGeec3AmevT27cnjR8fPTl68e/a8A0n2OznvJLNZJ5FNKeOiTpnDBzo3Qs9GOfMQ2/9X8Nq1aMGrMcp3xpb64Gw9hFu+K2jCp0ukRTpXoOEwpOMg6JZd9j+F+P634bH/l6Gl94m2SnyZkDigLMBxHCQBDlbBBMfBo9cBDt6+Dib4fTIRr9wCXXYc4EAUvw9w8FH9fR7g4BiaOK6YeJ+Lf99XVNShM/G8rEQ9noqaSanrzpILWV0+vK9oIZ8+0hnTz++XFVePz3kqH46TsuLiUTYEjUAD8C18BNWhajCBCcRx8IsarJjAI/X3F/X/I5gEDo4CHLwJcPAU2v4lEVN5Tj+J2olo79GKw7MYxi8w3V+qTJRXC9ECXYk2pqVoJT8T7dCpbqlK+IVsjavH1+LAyUbTzG2WynYvZMNVUcq2SwqJDKCHXD69yc904VM6lY9mwo9hYqL7x0/Eo5yUzJzRebLkKTT8iLG88zQ/TVkqPu3j+C7ui4qvb89uX8A4X7/uzHBHPZrnZ8+ePcMdWyK+WQ5PTzsCqMTDsCj85843/9e3b9/gq8vBBncu+5tADFz86vyYlD/qElGjF2D4bxTg4D8CHHQDHNwSYwhw8J9fZ/fEn2q/f9CXD/sDsYRvErGVQ+jiX/hf/+r3/vWvfwVYPv8HfJkcyhd98eG/nvWDCQ5+CHDw+3HnaZ5lYs8vN82MD+R1Ui578yzPeQSPySewIMOQwSU/ljQostzFf8X/1Zv8X//ZGwNnUWNmBpKNBtZ5PBje2Uzw54RcbvBRq00DjWnvT8pz0p+QQDwEWBQdMUoGExIcCfARBe/Pc7I/IcH7c1XjOT0nBxMSPKfnsuB1wi7I4YQE4kG1Ui4pJ3dEO+IpENzT5Qbht1aG93tBPxy+zSqeZEWA8KOatO/NP+WYIFApBTZpRlecQg4B2d9zdgX1sKClrPlE8PZ+WBXBIStzbaVUqDc+3lIeaQ2zHBqmaNiyL21cbZm/ys8pf5IU1AWHk9sLAb8CXj4ncQnezzbSlhZh9opVlpaRqBj3ZR1RnU9szXQeCVROCOG68GUyqtN8P75OiyJli44cv4zdqMk7VRb82KXdH4Pej2CYHw/uTza1aSMB4dKS/SgBCFSm6cE3AYQj/eaIUf0iZ9SWvz83H5TnTv3n9FyXz+m5LRdAqV+cCgCtWcQHOUColLM/Shwe/6krTsd8VBLKpvmM/v7upfEei0oZ6sHkaCRZRPWKjwKEIKAnqH7QaC/tzXJGR7ZINl6QVPoZ4IQUJtRfQAKEp6SCEGfJOC5wEEyGcWFkFgnC+kfSHaAJ3kd4RabxADZ5GvcnvZKnpxGCcPxqX2e0MYUV2ljVKiOXUuhEN8bDFWJZhKEafhhGnOQ92R4KQ6XhyG1kJwBDBT1SCbJxAwCAROTdTisEiGoKBElaSs3203Q+p7wwISs/0wswmNLlWpTPFs8ywtQP7dJPlDbqREUrfiKzq5N4osd1jRCTn8VHAb5s1c2fODnZqSaO/d5Q+xgasZ7pWAPQ7f8surfRMJ7YMJ3ZxXW6aKnIk3Mo+NvRcby1YIsnN14NM4KbzsYHATcSqQ8E7hvd2TWWl9Y+CcPoMauPedw6lFYQ7c1TNqt/r3wAIzRsHXkrTO9u6IaRS9niad4IrKdNE2pT8JTmtXe9WTqf1wc1osr8Wm7qS/WFigwXOUEu2ybq2QPU3rV3V3rd/aq+0N2VaOOL4VurbTFIGFHtwvpoNqOzlyU9bXN7K3snZb5YZBLGI9r7TC8w7alI+NKUE3ZANSY7/W7NvYPz1WwOxAkQtga+CcPWhvcGaIPalqi2cX9ziQQ1oU6dybFJe2lJT1vESBKRdKYJkzE65Gg7T46PO1OJBjr064pTiFCXFB3ZcIEh8jJ4gKum0agxV1GO9/rXWrltGyHb2LZgGolvW6gwjOqJMNdragKF5/POMS3HdJfXdH1EckJDhaQ/Uwiq2GyAbWuA4b09GrMJ2tS1kj7W/p+d0+A6c7qqgfp8nCo1At4xC4ioILCBTkJh6N0Ni/YxlGNmSYteMpuphZXEh4rGo4KfCSLfre0s8dYPNtpa5sP1aKQf0tNVlk7TUhNHbPE850dzTRNJg0XmeOYRfgO6B6LLbLVaBOWt6eW7EBdZsqM/Z0bEMdO6NfguXdMzyq7R9X/sE9L/Lh3ms60GodI+SYzoGjc9OOxfxxLeD5RqyGkdB8nQ0TNFVzNDVwNMPU25dPpya8kYDteHKNXWVupRwy9t7/s7UbDPc/6eJ9PPjy+uMMktZa3nrGmXO2cRMiGywtBmdrEXXxhOc1bkmX3onSec+b+iQHVi0x4aQQDufKrKDqdTmp7RWSfo/nJ89KYn78F0LtBvN+h1jintLMtyVQxv307YosoS3kvz27N8Wtwui9tib4vydrJKb0/z09OcST317TdiGW6Z4E+gt/7X3r9khJ9bK56vkoU0zhKM/mnOBaKf51yGZuxpQx27RtexR7729iigbAEUagLpG8il35UidmGuBpcKDgcjl0pW70bGsFCdjTCkyPo1zVxyf+aS+dRQ9haFK/DUloZwhGv005OEQeqhlM06SUe22Cmq1SrnkKlCJZz4EVJj/NjJ5x0Ij/Nj0I2iklCkUg7pBEeoG/zY6wBQSHJMNVXocImdMu9oKrHoFNV0KYgyoAOKXqBs/UoTsELN0b1wdZlL2avFQyPmEfaaoGftBP1uKhUzEk8sqXq0ohxg1rXwAs8AJ/mcJp5lEHkTG83HmTq66eknKsjfDyk9j0oLhxDs50OiQqyaueFbA3xrgHCOcAYy0L+SiOIUjaTuKcoUjySHko8bvUrKIeJoGLWMaUHLiCPcKIdv0kav2PQKQTuU8Eplb3UztyqtEOUQglvqPlnMJxCZD8MTp9Ocz9BIfG3FYC2XjWn3YW6zwqatNeV0RqmOC65ufI5tiSRkcqfEkD0uTG0MBLycUVampQIbn6Jr69+wXxIaTDcOuQXcQYMz8FarRnjSlmZK2Yy8xP9K2jKjyDXWFyKkSSk3+NWOC3/3dW/8Yel55/dE4/AlZRrl1lK+CNDc8kp8Jabb8kVLcb2P8kZkw8vtNEPLsnrl4mMz/Wo1S0oY3nXCB11zaO+XQDvWh/ciiZzX/w9778LdNo7ki38ViTurEGtEsWf37t2hhqPrTpxOevJq25l+aHTzpynY4oQG2CAYx23pu/8PnsSLstyd7rl7zu72xCKJZwEoFApVvzLmBT4h0G5y/iYtPqnb2N6qWyw/mxb7cwDtHumHtdhZQH3W8II6GOd5QLfNJhZFRwRcoCl40PzspQxrWKKFR/aEWIHu+gNA6wOt5uzV/B2rLtZ8u7cPar5XYNB8xbXeF8FI9Quxb59YhOKw0N+yvCh6JFMR6DVsS6A2QgeJJSjb7XNlZQsicKosMZ/f5xETiyQRsaHHV29xTACRZUic6FMk+yLoicDcGlcxOPH69E4/8NWOBGXK0q4FfRzEtx2rEXPCTQ0MPi90aPz98uK1PPVns9vDgeS6/3K1n3yuWi6xasjgnRV5G25I7aht8EBp6sp4PA5TbDamleuiVenP1kWjNKSrNGhLPF3MAxLS3FF4uarbzeZuCyDxktgKYZFC2vtJwSrvTSIlloKWxqq8TgmAXV6Zm8hO3kT2r4COpUTNDOvkpSRQV4fjQ8sBc+CWsJtMVNHCzrDqbwmxvCWsnFtCpgHv3FvC8dHWVBnbGby5Eg2CZPef5nXq6hY5ZakhBpHE6F9p0ZRICsycWa0luEW1zHfN0kW13N5PMTKZqPqVZaZPMbqbYooB/zzE1sBd1LFPrJQz6W/QCAvRuONL4JPAlE+Cy/MEZsXWl4RXVduQ1rXARC4K0z5xrcIsvMdfCVOS9LfpNd9eUwZjndyjj/t0SvYCwK+lRczPBfzp3p2JWlKXVOgoPCYrNqN4fSr6gVbB59buu/WeXPzDSab94GzFnr/7Bb0ym59ViWafikz+gDNa4PaS0OuYhZJp2hyNla5XPKVekcrrWRfFl3cWEkmXEKHQfPBLlg6TNagCPsfTG1o0afAFgCw1V6T9VDai9X7Fh8X6+2DE3ci5u+kHG/kjrR6Fq6v2aeob6MwbN2dkVaVW/DnnHkqy71d9DyQYZdAPpxW+3+5TljK9J42+KvgO+Nl+9bW2XFIqspdYhJp9VzVI4/tlXDJkB8kjodVsqkajSSMuKiZ+e4I1bma6poGeiyG1wG+6XqPbo0VfX/uQW+vIyIZ205ixnLl0wvGlRtT/zjPU+7E36XumLPbPyUeEEwC/LfJE4osl8A/7bFD4SgaGEOYG6DJfofRBcbIEFl6RIpb+WABohcaSMHj3q0u0z4FeH7IITRVyedkiFtr3Lw7h4XIb45MtYm+9TJqbq8L8q9R52Cu0zbxgdleInZWU1PU70lbuPuZyT6W+lYlPUcuIUoKC+cLq4LQVCb6H4bsflpnsnuvYKL6dk7B+AywwWLPig04t50Sg1UK0OFr6PpQqwTEu1x6GmdYyD9flmJYYh5KfOkRvdYCyNPmX5AAJQdoYyfVIQbp2Hd7KBIrfWeJCwIkqpfsyAY5h5nDhgZ67RexFxbtzG/Tt1xBCkX4tixbWNKotVh7OHsK3OQra6HYievK6Quwr0okLhKd1hTA7RaXAxRfepJfswG5WU1yh7+WqERAXjDTB9x/Ud6VnlmtJu+L7Mws/Jnxu0cckMrsGKObD0ukzolXBZOI8mvp83KnxkRbSf5DRk3vdxzcWlMMPhdBPfF9AVOZ3wvYlS8SfN8U1SmCFMaIv2HWdJfLn+etXCaSoWBFc32YJ//UW17cJZMWFOMJlCSsuhPI62UJW5nfJ3y+SLPmqKD+2TVGiBCZ/Z0mWnBcXwor9f18mWfIM1YiJT5+PeOqTtiwalMBnqO4/nrRl/+UVumRZckwpueE/E3haXa31G/E7ge8b9fy+SeAzcoPVI/+ZwNcId1mijk38IYFyQLJE/n1Fyo8J/K7CWfL2LNlCXOZ3x1lylMCvsuSPCXyaJf+ewGdZ8h8JPMmS/5XA51nynwn8Okv+dwJfZMl/JfBllvwpgd9kyb8l8K9ZcpDA11nyOIFvsmSawLdZ8iSByf+XZIkw/v/8p8MkS95016Lq7ewDmsqA1en3Ra4e7JOFVKa0m00ox47H6dF/Sp5XkuumoEjvk5p7CugEyVhoCUk5DHBsWdH+uvChTUFb3zXOu1oUSURYjeq6kYsbrRLhRXRdfEQK2yGA2pkhIQ8w+EOx2aQ/FLnvmrYuWq2SHsCWEQE+3UwSeTnMJIJULdgyD9H2d1fCM7lZKvyJfIxAFPBRmaU0R2DBlorcFCqwCbuAmlydBDibijkYG4BUX/uLY/TceUoRyPSLmlxJRA2vhp2Fu888eexd4LxYk6uvKemah5R9xTPE3w6Wf4Idf7V9ajjBq8EP/DC5B+hawRg9J/zb66IZNPVA5QODdqoVH59d3xdSeSPhKOx8jqQwpH5wxYmdRRwPITSF6YKCPP2HWEvTYrU6+YQwe1W1DGFEBexPAIJI8DFePS1wieohbIvhoqBFfqTU3fE63Ur5KYvvrSJtcLHqfA36Kk+pr0nXIj+7IxtdIfZM+odoLp1qywxZcNKXkVhu/BWumEyA4PgQjg8BZLEW/MrKf0G9DUWfZEA2XnAemgv3H1MAkVJAKtzaI49Htu9kBk+lbYZc+daYVDJE6jh3ip1Mxs5zwLpfagEnXomRf4KMWhGrghBHsiel/JRUEtZnLTDAdD4tiSMwVzf1mGVhhKIrxN52bFcTif7sBWMhKxGFOp5Jfw3z+Id5L1OEivyfeAaBDBXwsji15DnF2rFTBA0FbRp5JQqb0aciXF20Df33MFjNWXVRV/hqoLd9At/hnUsjsUNIfyw3cVy97vN28NdxCB3r+1C+45ZzLldsU3cPLLcTQtyjJ6YGScePaEoPDgBe0KUMaaplPq/yGhU0bDSvdmbTdwY0hxWPqf3NY5FF0yC88kdNMlfrW8BareKDfHbVYT7hxxhmlBuR/Vk4fcZqvW+kuYTcP7mUABD5EmCLKJOezZEG2Z9THOzs8vNxXQ8UgHcZ6cdKj5d/yVAYmy7Mbq8UEMjSMQYrB8zw1pxFuOvngaXFD26K5wZ1eblkNVaGSEU72F0kwlUbZpCVqEBWQfFCozm0g5XyY1BFmEnZc6n30d3+Kbke4kf3bfgqayBMy696w/olkoTa4xJtseiKE3r40YD8EnDYXuZMRcTDwfr9BsR7ZqLGD8iVKc7x/pW8OYvI4JqEnwVT+DVd0WUM9OVM6O7Pi6v4qTJ/WF/S5Ozp6ct35zYejhcsmgFIow1ht/XA0El15gOHLml5gdbE4RntPUJ7m3hUggwEgfFUC9fFitycEjLAYfxUPpzJFWL3FdGa70HWF6QdyLQmrb8OaoIHmJP4JHoqsd/dShTx2q+k25gnBzpHt3jqYAd1kp0XV3sXqdKGpyReVSDLqDLkVYXFFOuqVAgMVk7o91w7SIWcU2cRkLcDUsU9ObWtVKhjiuW0BkoXoM/xQREtYmLVRPZaMfkjSifZmDCXkydJwokbyWFhlMqMQQfjrbNwa3XJosDNJkmMKDmneY4zarDnvKNDMJHsnV5+9IZYs6DXRTMgBXOx93XRCGiTPkw9jJicKzglLKyiUwpmIu5aSoSrAlQmOX1Ml4Auhh8OUdROE5s5Vqz+Yd2Gmy4in15ZnHnHmhxuif1xV0vcdJGWtEMtUbPZacTO3EEzIPVLkC2ANLqahwgSfB/gBrvoEUkT6Y2WeY5vCoqGtophpYDS4gu5NUXAP/bKTeoFu6711hm5mDWXhkatroKkyMznr1+ZfTe5LD6i84rxrTaYHN4mvaOmEKouuIxzrwLMhddo8O7Ov+W6Y6TJDuEFYYxcZ4ewRpcsO4RU3AUdwptqxdbZIVwj+WK7DU8XIjBxnOnwT+HBwsugThbiLeP8zs2h4AVf83aj+M4w1pjwWnqUot1kkipkWdTyA6X6mXKuiqbXrSpSq1pFEv+lSnyDLj5WLJIh+iFl/g1AMCt3zF+/E8n5yet3r47PTwTO7YC2iVcQyMWeuknEus5zcaI+P/n+/MObt89O/GLU+WX/kp6+ff365E28MKsr+xV28upkoDC+c+4UFLXCshcXJxPHvZ0vUdUgv533iKB2KXrdPqfFVaSo64ZQ9hIz8sy7D4xwEULlIEs7OJ/DpQjAQBwtVqQZJKcp26SK4V26WJdoaFtL1gKlPxRcPyHM/opuowYDH9HtzPjlMctHL1VfpTPXZYWotvtK3uNKv1wlMxdw+v1BAgTYr8RUm15Scv10XdCnvG/iovMlZqmN/PtHAI/+EwD472Kt1AoOcTLBJZ9Bb29wf9kkS8blgi1BL5fwx80m5L1f1+SiqEXvzwt6heJH6UTeefGVyubyd5bocZFvUZZckNWtepjy33FVtTIhiWwQriFIkNGgxw7m1HTZAwzVCv1TlZtNWpX5kPnMRdGiBIB5VUankuili+SM5/xvxocBUl46tUr3jq5FAgCkpSv3yKL5+VnCgNPSIKBOy3VBj1l6CObW2yx5khxYz4G80koiBGwa3FVlHh2n9y2ix1fxrVzRGxefqquCETrtdOJgW3xWsCKQjqR5kKssSFYFKx4nB1HZNSglUFxFiwoLekqum46hlX9cMeX5aQJeo32Qv0MXx7i6HpiSve+9gXpStLfZnsjvbXkNosKjHZfoDbkZJr6VztxJW++mmNzM469TkIkoOc8KhoCUda6DYHi6m08J+VihNmzH+DBCXJ42RtVnRdovAJEqwAhuI/n5OHv5Yqh3CBwkeXIQxcMTQHqDFizmTsQHbmTTD4Ue3XcUXVafc+1CLUy7haXMCV5JEyouoipDPH99r6pPCdR9AHobGeesPxBjmJi6hHUVAJHqk2QmXLJ7N5JF8p0Q0wRW7M8K6PW6TZYq7pNxcSYHByBeMV2Q5UFy7NV+F6v+cXLAU7vojwfJ42R2QVHxcSt9VO5kk84NjbLkxntzglcJfE1+ttP0NEX861v7G3GyjoiXlg0Ws53ZbjZVHD4nQhQhYgcDXS3QEmztsG8PmSK9gmDYCorzuapVbGzXFWAkob98KWpJ/Qkd49VZIBvpE+qaKndNvmOxjB0kT6bTJ8kBjnOCZ29fCzlhD16gs7wRWEJSDH329vVebNKsdy5CBIrWUCnhDUHIL6UJuTdU8+jbLKIOc2bfYPHOiM8j74KiNY12bCJK+I82VeO8RKpyWZ5n3i7S89nR0RK9IsUKUXFSeSBozn5mTKrldtqBaJJuon1gW4TDEoBKfIF1mf9Y9LasXdlPzrErWPbo6jIA6aCBo7mOGAb2xdMPK1LmDGIJF5kCiHfFHuRpHGPetUKiFRPgmyIFtqRr/KtVy00CJUNHbh28oAmROaXLMCHDlP8SKQOjqmjQAp0/ODn0BUF9XgCh0VXSkEaEBksgihly9VENvmit66JdSxghU+8exnpanN49wWs/SsHAHA/S/XJ0IqeVMsjBnm2Uib9IvZyme9bKkz7MonEo4gK440t77qwLL14CVg53Tu3h7ciOQGCRKoIQCHvVMhgXQRf7oHAIOpOJgjDlJ1QRvgExRCMb8+KOF5epIAkrVBLKz2ttpj68RbCgV222qMvllv8/3zquCwCL0vhRnZ8evzl7ef7y7ZsPL58lAJZlvtB+UNkZg12Lnvs+UO6tgNUsEdklPWFAOBm/o+S6apWDq5VKsl2+5mfxaz5p94wjRqVQXgYv8NXjflNcJgBML6uaIWqFk+y3We/qAyZO7gTkeY62OyEgsb77E4CJYLuFK9S02aIoYV3CV2gJr7uaVXyeL2FT5kPb89aywKkCc3Y2k1dXCJY4Z67vSLFanZPvpIeY3cAPSkwSIGznqGXFRVVXtiF6NM72ofIAyJFABLMyvsTnFMm7mV4rRkMw1aekq1cjgwfG+hKEn6NSgNvxdLZQNbaug/ZGz6AjndxJx5eGXxCXHfWF845y7GSqmEu+um4I/Xgma/gZ0XazSQe+5IslGMolQa5CBePOThu/JH6SgzQfH0E7bCW4ozndbBg8zPPHj/FkglIKtjMWnatoerNG+Ew4NKZETlQ3OmFspAPuaKlCLTnVTBdhmmXKSBmYOdIsndMMz8V+bmuoU6Y4bny2IWhkH9LyxHB8qBjwzgyOIabOpnxVnRB661KqG5IOyz1v1aMmPn37+t3LVyfPJhP9a7NJ+QzAV7n4V4BfLNAyZxLWZVXmd8dNU1dyazhFl9kHDN9c/Ugwyr5nFt7MZWkxkVd8lEQBVz37FYLM6wIXV4i+q7urCrcJgJ+GWIgPKCt3jp8J7r1phTE0P+qfE1mguQ7fCZOLpteyFTne9mGpRINyHZoQTCn6hKhwrY84oPpy2dA1siycD6xs4HNx+RSKdTJXwActIfGX1xQpJFrfFWI/OiY4Xtmc9J5jtFPdkM1cOEwSB871DWUzL0y4HpJdtgwLKmIyEHMGTQ2symio7pbXDQmAZBuLviYyjNQEGck2jC5Jh1eS2YvPyQHSftu3g/NXCzv8XBXFOtpzgCU72ufcIEk6jmxh77GiEFqpLjCReZQc0IPE6RnzrM/8qUr11OG9vx4WALQr/22N2jMkt/szxAYIIVRWOzAnVe5ZfGEzqyIuvgrs7NR5W6yEaTJWP4Be+QTLqgXmeuqvCeer07pg7RzXtd8Jz8TrkpLr1COLJuTFlzq8r0nLpMZNkYy/FNUFb01SaSg2XaNidc+x34zUOfFs+zxuHR8nOZVlcwdNHx0jZuQ2X7XUNomkIDDpLlarwPJQKWfc9vuj0aPyubQJr6G4iDxQR591Jfx6g9zDkyrAFOnL2o1E7/dL4384TiA7wWV6Eu/YOQUTss8H4pRVAvihzO/aT1dZsmasyZ48ubm5md78+5TQqyd/PDw8fNJ+ukrg57Vwsw6THP3pT396Ir4m8HNd4Y/DifjXBH6Ol/P961c82X89wcU1Ur7Yn69r3A62S3x9kmzhTZk/+VcuFP3rkyv4tMyTD/iKE/+xfJnAz/KdMlLSr3v556zU/NqFfWWRfUv4n7gIFQTMRQmEH8dTIgIByXBUN5yva2BZ0t+E462p+6SMBbpi4G58xA986io9dEpjnlOawhk+3ymSifmCLFlOg3q064Kqu8ZWLA0lpmmQ/q9un5Lr5uXKCGkS60G25lSHFOIfX/L+DCNNmbQu9+FbH9psxsyRALzyZzrG2BThsmjarhaCrYqchdn05Jq/QqvMEkX8Hgj5hU2rVX8i2GxS5YNUpgGF4vSBDMQJJEQUXjzEQOxYTVPf6oUNIJ7ptspbiUw/qusJcp3pVqGb0Zv928OpaKJ4GcDtoHV8fxWd1/z8rJStZdKotoWLpYKM8Kvod3qBqry787Hh6+1AIh89BI0LxE8E1kx2PyP3EkTtwy/vE+diM39VsEIjCiq0cRFfPzaFVyEHdtt1vz/IiM3jRhhvztIP5YItIQLZgJmGD251rz+NV47tPhOWM+TJ5BXiuHegX+gqh/b2MJtMPD+u8Oyzw9eO5/bd7VwwmRqVzNK3RHb0SLSsASMdBDIkwe4DIf7R+RqNWpVQRwQcrSqpmhLGk6MC32p9VPvI8j+yRaokgZ7Grffku8/vz833MLdStJ/tNKSClVNwx3J6kGTJAZvJbfNDyfdNMg8so4nUYsdsroWlQdQYOxz+YWtugTOkuN2HcoGXMzqPGUZTyHgzfKtrLLthWhOzyka/zLUjMon3d+1A9/tl8NGgk894+qxo10+LVoR54+ls6BBpms5TvRRWkwVm86TSP5MsScTgWO4dYbPjbhc4WrXMYVkKZp4jiNexQYiTt2XKYNKozwmAsfYN+kH2HuTeeqrFWXlIUyMrrdV5OgEwwh2CrWaXIuekTLHGZvTzDKVW293HMk/+TyJM8Z6SFRLmeL1M+7Y0khVy0+R5/rEM1QzPhZ6EcT51i9kasaocCUTAUcK5lQlmX+Gy7lZohCq2RnSUfEXJTYuosSBoX5NVV6NkxBndG0Ka8EuFR7eko6Oi105OH0md47sSHg8fp+3Y4taRWvjyiJMXEXhCwuwqpzNpDXRWppTLJNQWcczpu5dqKgCJdmTg6zv/XNqCPC+Dp+AnC/H5aezzjgO4JQo6uvMh3mr3T8oqumqY+MbDA4KHExd4ILVTDTaU2aNVFNq+H7phwttym74sAXyzeyQh0aDC0bGswlMJhpUgwkmt4l7osSawsozTc+KeEPI8t0XsOZ0WjBXlWr5J767JCmUJaRBOtiCjEcdKGDZGaypSu+Y+cEjN5x3h845Y8w52+eGs+3OtD5adPli2g7a5WrfSOoJAveiWTp8dGas14mu1Y0JyHviW3mOfr+ExJdnn+migsvjePhEJOX6Y6LUwqVfkPggMrrdXNLE9o3gFfmdTBgIb37goqnfSsDo7/V71DfiA7dk7K/Ev6V1MUvRMmINi4pLmHrUDYLjAszKP3Wf9KPC9+b/TDx/a2+sLUn/4EAOLSz6I6wuTJjlAW3ha5s/KNPF3yQTAv8kvEQilBMDXZX63hf8oc79QK6zXGSNNg1bJbHerF7yWr14dP/3rh1cvz85Pnn04+dvJm/OzBCwnk/Qdr0jeXr+KOauMx+/KyeRd4DnBT1Xvy8gx5HW5kDg1S3n1YilsTZhzxeoXMs0RZ3saT0W58Nc5XhwuwZT3fZzngvoKQH9ei7dT2uG0nq4LvKqVtgFSkJk3NrgeBVZ0I6xv32CVH86qP2vc/clkfDjOc7T4R7mcVZrf1bO0zsmi+oJt2W63W/jiVwgPmlNOsbgjzblcPBngid8W25SCzYZMLYCt3ft/DKdLRoaNzDORbjKx//RFTSZj783Um84tI83L62u0qgomhG01t3UY41+YPcg3lHC2b0J/p1AIzHyy5ONDAIfxHH13SX2NGFtsh8Edwz7XdqJCkmNxpkeL03K52XzPplX7EisjCT5NUjCZjF+VnOdF4d0IHB8BYTWvhJ3XpViwm02qfgt+dfzm6/evjk+FxP38+NXZSQIk+6hztKiWsMvryaQ27umzerNJ5aecy7NShhDNmIuVRPnubK8p3ovDPM91GaCWauk7PvJZC9WayshWtVYv7SIfH8EyP5yVvdxSSmP+elEu9WLM85yAuyIfHypb/GKzGa5i2202gqQpg+9LYQsZ2mkZSI8YHh4fKuLD4UUSDgwuWvytXKorV7PXRrKryYfgQgLwKVoTOXSwyslkghZEFlU9tKheWhwfKdmwsmXD6jKtFp1NYwzu6nx8yGW/RvDbDh4BRfF6zge4MozXqVFQedmrOO5pmti+b0sAn5f5XVPgbHwImwILD0L1m5eifiK8Ur9KAYCoHoTHs/wpvZ7l765RP1bkRhZc4XJtfvR18CdTC3/Q9fDfVk38sepLIp3MTlHbmh+yUkpYwVD/y9QlH3Vl8knVJh/66tqbqkHmh+6jeDC9FE+ySvFT95QV/N0W/tzb1rworq8R/Rq1rKPoqbBHTQD8yk8gzeQTAL++594eSf+IxVJdkn9ClFYr1OZ3UTz2i66qV7KKiNjB2yA/pkphTgTyftvPXczP88J3JU0E+RMgLgLuELatasV3ScpoAqetQKbHMqH7bYH78ztTupCfftVJU5+VRBSvy+pKnDMVtKo4aNaC9vyUuWN/37UBpePnoajnejHxbUR5qT/tWkauFYQl2Gy074AcCJ1ONkqHLHBC5wp1s9YyS+OQUkZFvUCjC6HouUBl0bVIDe70m7NR1QpltCh2NSrwaoTJqBRNkS/paF20owuE8KhtUCm8iqePADzyPfIftr+K5iujHW3IlEoDIwF1btEI+pSwCKFHeHwEa0fAyseH25lrEM7TpyCw+OUs3KkAmB3IjUzMyaso8+L49euT0w+v3h4/OzkdleS6qRFDKxl1LSAu50TS3hR+ItUqdVq6BUIqqPMB7R8GYAum0vXL3iXjY8/uH3tmdcO0VA31ZVHVcnjdNm4dqNo6BYapEC6uv+1YW62Qko98c+oqp3qN2XwnRU4tCNyJsr7uCrpCK7sQLE0X+hUrjsu106b+2+Wl+LgNYAPtFTaIFqEbKvmpCQGGwF8eH5nd8bsyXyRFzRKJAUpJncDkGrEigUm7ri5ZsoQ/lvldUbu+GIYRFzX7K7rdQpU7nqhktBapeMnxJPyLSCJqjacRn3iiLfx2l81SX2/AK38Z/9M+ZBJj/UTb9QXWNbsYh3V6C8rB/NDJ5Eg9Lepa+CaQ6WVXc7JpRWXAY1xrueDz7vlsm9VY0M8pgmS6UnOLNw5W2prHaXOw1+Lc2xCEgMfShDMLyo/XfPQkYzy0jvabTfIR3XL5IhnnOZ1M+GPXiIfANJrT7gMm9Lqoq5/RX9FtiqcNaVLACZgkvOzvykHzL5ZjaxnM2F8eH00mKdaSKINHAFYHOTrgbd6K3wQejq2mHtoB+fzG1fmdWdm1Q8OcwlqPZl5BgROg8TKeq9eRm9sE9u5sGluDN1zplUZJngu8QW8jnuM8kRZIWTJNjDdCsiIs4Ss+pA8Fd3Qskh3CH8sFXQIJkcMOcqqJwQ6kX44zSYMJ7h+CCLgLupoS4QvC5fs4l9SEleb1W+iNuUMqZVODpBVNgtoyUSYo/HfRoMSYlWi2sDXc7w+lawvx1y9jCbmLyRS4YtXP/oXegDeA27nRKZ2+efvmJDNmy/rti/PXr8xbG5Hmm3LOpsJlr8JX5+uq/YoftFrLrP4MlR2t2K0KiyagT98QdlZcyvvFlMFExCWx9ijL4NJ47l/T/JpuNlzeXvMNUXkysLmEZ0kZyJJkhvNrKtHAEWVfkdWtviag+lj6v2CV09mK3Ck2QSI3fWJrHzEy0tQcrdl17YgFFW46xqWWjhPjQtxAkMePIc0rWAk2oEBR4Y4mbW/WVY1SOs7zSiszhI0YhV1em7EUGm2KcHpMUww2m/4S6lLERupTrs7INWLrCl9NJq5E9t3x6ZuXb77OdJcqfCVAiUYto1XToNWoJddopO6qRmmLeKeFXeHVtCRP8NWTVo3kv3xuW8CZbmdHmcRAn3faXLdz1jqo0q1ja9I6qNJby9TbjCgAZgaenf/w6iQ6Bb//IlPwTN4iOeEbubibIoX/kyIwZbS6ToFBD0pmGplCGKikz2i/YU4mVzRli6MlZ0X8r4D9EsneUOCqTXvEw/EhxPwfaV6JIuaVBlqGglnyiDNfMpngOcvHLHuUPJLPTHqH4d6ibDLBW4FQn6Vyztw/OzrcFpdoJK7XRgJAUVx0J/vNjURmT8CWj2M/jAKNNuNnF3sMUWPsGvcbShWub8d4ChjdBEBrXaseyb50LVrxg3kxktHyRipEa9I39v1pnOnhZrNxXrDmS0zB96ecCV7RNDb/T0/O3r4/fXrygTfKJx/+4uQ7VdgDsk3301BjFYzen77SlLx/oiS9SWbEqwN9blDJ0GqkW62iPe07DRNf+Rn0NNwkHbi1HyJWIKfop66i/Pw/EoQQ+mg4uiJsVPCGCce620ag5KVgz2a6XsW3TdG2us/ntGvZC3ZdR08N6Gb0TRmcEiIlDCIp8SK+368IsUyGykBhCJ9IGe/pYD/YXgWYeTlcEFYFbdM/lAD+cJ/N617rJe7jxIhcqRHEFDPFZMx5LjUstCnWMr+oBDZmxmfP3m3Yay4pdd83v0c8MGumRyggZDoxDD+UAH7/z2+Q3OFNi1Dzz2+R3KNMk9g/v0mc35v24H9+e+x9yLSLNvknnNYUJhfSti6BPdbBO4F1ICMxm+9baL6/tb5b9ZHSjlCXAtiUU4kVs+1BAfpSrgteijBHzdpSwQjU5dJKUpdR0IUI0q7MvdwuLfNE0rghaksmsbuaYXbGt69ww1Lmh9K0UCioi5qiYnUrFdVSmz0dvbwc3ZJuhBHf2soStS0//5Tk+prg0aqiqGTVJ9SO2q5cj4p29Obq5aXQgb+5ek7o6JKS61Exqoufb7WC/FrUCEfSVnb0VBSlmsE3WVSs+MHf8NWbiq3PROTfHswpYohzh69kIRmCitQCKUOT/dwaX2H09XJlDUohBuXkc9UyzoDP2RaW5VIF24watOjAnfKvPKQ1nuAgryVW2mWio3XOtrAbXD79nYvGc6CTSUrzpLpuEBWOL0oBLj6SySQl4iQMZpFbGoiDexqF+VgRfE6rqytExS0NFbFK0UrCqey+rNmxt70xhZ+xgrK0WpmNrFpxYaijtYyWrYhxkDwCcvXWDYDtbrJELVCCLhJerohrc4rk7GxzutO6ZK8OneDVXt0RL93qnSTuJ7f/Ptz9L+w/RUVL8JfotNLLPnAYyy/TDRHE8osMnWB3+w2eqNQkFE8HidW3Zo+Vu9c6jE3Satr+uvV3SjqG2lNUkitc/Yx+oxkLR6KZpmTx5FBp/f80lYTatxURmPZnU78BlVb3UQlWyuLvHjrVUTrVhk71tF2Trl4d852av6pg/atJ95sxxAHCwZHbif6789qh8OX/0/PwVGJ8/lPn4NV/Bwr93lPNos+nHVK1yEI5y32wEkAwammw9IoUKzkFmoKtTVNEuQJpULZHoq78Lq3h5L6/Ldf3taXFRdOuCXtwc4TeX61nI0rKBj1KDlKncNk22XZl0xL7JBq/2SQJUKKKRB/5vbrQU/TLduDDb9aB34P8N79D638ryj8dbLuFkC9KodJURh0AGxWkX6NEFLhcE5rjhyoRS0rqOpW5ex4nnwVj0xVZHdev5s7T4nDJ2akqwbw9WgqYNafTnxv3zvqsyZOGVtcFvU3gyX2j2RS0uG5ztNnErSnXRdT+xcob8/jw4Ihy75ZO5JbQSA46lyxwgUxAXBeXhIE5WxwuM4PbpCDnAuyjL1hftmBLVd1iOQRv64A4f0S37SCAq42dbjUB7IfM3KubzhtPi34itOjm+8vGNU2U8LjaAudJIqxuTHA4FLNgqS7T5LKra2EwIrKLyEUCvWVdtOaSG2w2uiBzAwqcknqfmrutcqYxKPq9A01OpVsAWlTC+Lx2ortkCQBkUVvRW47AMu8kej9PPc7zTrTSrlqN3F1JcNtdo1WmIfUOITWRmRvSCrTXNiMSc+ZjVF8k+EarWYbUluU26uDbRhlCaD0QE0FjksQyLc4PZ7i/J8a68zRHC7ycvWtSCo+blEEKwLYfzXeNhSoTqgz/jkfi/17iT0VdrUZm8kjN5OVINF3wo4PkUTY6wSXpMEMUrUZGgyYTTXVZ52s0kiqL0XV1tRbGlgUeoc+MFkLNWEz/jnXik8/FdVOjTD9zcjNZYJuN5Pl3lI8W+vtodDdS/P8RHFEl+52TbPToyapo1xekoCvOLvWky0aP+FR8NNrCSBl2lpHxoc1Gz/R7E7pitIVw9Oc/j9iN1JUWbaw4xIqqfpJVvDyruBeIkmfim1Wezr+cyV9yZbl8BIFwzPYdK1GCZfBqDJVlRWPUOw2LkPulWpbioSbF6ql5ISLW14j1v8Z5ftb88rYVPXVq1Lbq803F1qRjI92SEaEjuyG6M+viExoVI1xco9VItmfUIib7hab9rODt1YX98sb25Qk1eOm15kLdjjNyhdga0Xgz7H58sabEiDPUnNIazS/TGEOIhzbFGyA9E77cCJlFdk9D+LLtQ/ZFACf3bQAvSFStStpdsWHzLin2X5G/tKHT0VuM+Fu2RqNLUtfkpsJX8uL6Ao3U1ckq6ylo81g4uDCDbknCWi9+NYXlliCbKta/At0oJO0J/6WJ73G6EJhEtU8G85JPfRyvXzkL1MgLCURwtFExauuiXavGJAGBxv5E8Agp9rGHt+pObkp/TxLhAOHulsmjA7vOg+TvyZb3QAKbqIkwemSqfzQV+7qy4VFGQeTSTjGq2tGjRgRDeSR9PsglQ1jZUApbw0pcNXYtUpvy1J44Y6e/k4kUIYO3sgbv/a8bM1EEH7gRwfWt2CsR4y3V3eHTS7Y4ATN7XXLBzTxCZonRx42HdYY2GyYaPEeTyVj/PEieJNkYTSbqhfyTifcH6iFJMtQX/KaxQyHaXF3/nl4XTfqmEUDl8yq920IE7/THjG1BJl9qE8YxtvlOyjYb7HKbyQQbAQDbAoAwee+hRz7zOvuWPmss815Ic/sEgwAkzgvmnCvGvmn8+MhIwpFjAGfmCyyOActxnrMFXvb51I/DvmGnzY645SXBZcGUicNiCe2z0d8ax4lEeyDP0UI/PFbn7D7Pa0UFx0cQAeQffjmZGe/GEmKryn+4VTZVg9LvUwBpEUE2HR/KyAhW/ld2/s9MWoY+FX+/TXW8BxWdioub2YvWOQ6+bzzcJzx3TzjqtRrsbYokFJw8F0FmP1nGsCOJXybOJV81KZu2SMQ5bSE2P0E/hvwkPsXd9QWiby/1vBzz06X/MpwvlBMc93KgqJOZ5wVdOvWMUep8hNhJatJuzbxKpYs5ZOIPyKL0cee6PvV6a8K4K3up0SdEb6OYuQu85EO+wMvtg2nvOViMWKpuCKrLtB8FPcv9BcmHrc6tdPp4bBJCAiaTMXWP/LNY4bYrjJ4SfSJIQIQL8FGl3qhaQ1UFo+p8hNRJGhlVqVkgpltBowHszOfw48wik9WVmpPEbudZs+Tr3n0DKezAVlzZWMvBn2iiiS/2U1wSo7G05oRWWl6qIMO92nIPZVVfzv0Rx5y0m00aeZufN6nfPqBhrJ2Ueyi89lK6jn5spi2ilfAFkl44Si/6fAdNw2AOenw0gfVAaupKsCAZFe11kzIY5Q/IpNtGAVetRRTpiqjIZ4V/OdxL6+hn218DaRafmvRfbGS+bZzx+HnneCgis7XRyfcBmNgDJrTJdv98tpOa6Wy/NLO5b4uZzHa6L0YxtLYp1msWv2q8WWYYLjObDfL3F+SibhUy/QIvxe+tJR18bYt4+cJow187crFVMAV3NNeiY46VtJUy8UmEM9iZdbwzKxYc8SfvVuO7odljR3dysL3a0CVVwj9U695nUhw2XnDRReQ4JYSdSU4gIMnFy297Xta/1CHdUxBglypmFNYOsfbUfJIcxGQoT7EOrIUEHEQs5mw0c0fY4TvP+AhkSQKJO5gsMiIS2VSNCJHwNhIilrdrfCSGhPRCMj1I0uSATP9BKpwmT54k4CABSUZVpNqvHdZoe4DKCTNfxNq6zBZU1YnF89aMj+j7QfIkTQ4qr1Kzk44PwYEIGm/LTSn2TibiQOWPCc7Z4PUPBnPsZuqX4F8bHR/5r7yBW6DaNklA5nzDYAs0Z50n8+QAWymTBBzEFBt6K58n/2IFYE77DyKr4qs/NmJWf9f0/OJb97hhpBqfAj3bQX0XniQWa/iDU1IsSLTBDH3yr/9x+OQKJv8nsd/9+/GTqwommfPyj//BE/7BffdUJIR27X+1axdNsUv+SmSY2Rl+2JHh7ymv9F//+F92tX8H8uWf3Lb8pyh6Yhf9jV30CkUo0af93k7LM1oVHsgKDxP7fCdGQF8jJwe8G/IuS87rfv+B98xpVcRMliFn4Q9NymSYZTXCGolLmqizdf7k/y7+79+fpGA+y/9lefCkn0h4basppDtkLxaPmLyPTRJREJUF5fMJLwQS+aieqvU9F9EdrfXWT9F1UWG+RUZNDHxOPSRJqUu/twLfp6jFzIZCc+fWIo2mpg1C0vJQ3TjOEzDw5V8SMOdL7nmTLpbwbguy/knLCy2y+HiAcO5sKnb7JZrd3Xamb62DTswTAFbkrq+nL4nPQemhHM86SXqECBRpk97T9iYoJ0RkKbjkNZHh/OpikrDWrXpFqGvc7WxwYGeScoulOFtGhy3lAypjoKY9+cx2r8JE+LmeJAbIKPi061uagBmQzS0a1lEk59+u+uU6072MlWjAkewie2OGFr3jx482HR+q4rAFQTFEFCGJhUUcAQDTXj222USVH385FPn5Tp6rVcBlSS7GhSMeWbBy2PDanzS9ll1ZAfkNnyURHf/JdcNupQa/o/VIbXzOjWPPS3sLHVPtQfLICp3pkBpJt9qfm1TsBNZCf10wWn3WAmJssdspHDao1CAoH5zaMzON9OCIdb5rGYs0Mdk3SmR99tL9ZHriSPSUeKvyxARciZSqcax0kTinYIsW33BJaZl/I4SinSwxJjrnKfO4gtqP6BoAvQ8pIdmtXUNP7NUhEiGc3vlIbOcLek+83tOcACUdf8+7Dmv+l6rLS09/XKlmKDMYVyDtwGaTCoTMLl90SwA7yUxqHcyBf6pjpJVrOtK1u23PLw1T4axrHKcT4OzCGwYD4WkwQIIpAak3dgsNoSNMfZInGuoH6B8zifcTxr+VS1n0Sqxx19g40bAh8jZq1uP7cBH0L4+P5qlA9hVWREIfaH9Xq1oTgnjPIkmGhHfXWaN9u2I7/owtyDI/ynPnDFKZg0DF+aUlNVQADuxsT3qXOz9QisMQB430+nGyzKmCiDluvVF85xgXRmZH6mU2v1ZjsGWMw/iBzatfUti324tPwog5zaMTjT2gQAKnj/TxqHZJYyv7vqaka3K02UgBpYuk7GgtovUiy86rXXu2d+9iJ0Qm/ZRSnqBeyyiPvcBfPLiMLiijfHAZag29xfXtqLhoSd0xZC6UW3F3KvZI2yannboGWgLM4VEimsIXQDMo2EPjrKCHUZmyI6q1qh2tz7S+hOYYOjTvwzFcVlc5Uaa5dU1ueneG8aFCbFdOpjJScvodi0fKbZr6NpQ+bJ8JURr63BR4dWbNktSpxW6Y02apjzhrgLzi+zo2IDpcxXuZJWUQmey2AqN/a079W6AKXhVOyT6+SLfucXt9gh1Bc5DTFUg5wC6g1nfxaIqJuFiXU4cBjUSy9QUdUWZkh/l1xN1BUTvmpEtRDH1K7qYgCqFEDAGYSwCkCYACAtjphrAu3E2sD5Ml7WKmAo1FUUYuNYdViXUXC3WmOh6HJYUkR8E94KF1gE1Tmt9tgRDhhRY2Q552lEQiNIfD6FVv6f4kvJ/XhskEu+rOuTU9zFvZk2DwXbLKfiA+ulk4xwQUHbPu4CANdyC32h0ArzPvwjXF6rL10NvtzYWKXosv2lSHUKjyxRLW/J/OOqC9blIM3XIFPhcsYJmnbU5gkWNIYyuIN7OALdhFqY7LJHzezojUxVZSfCxBVutfWwBftMpsQtx1VVpDX+uyPxUpgLf8n68jGH0dXxfWReiuWRNMGNu50qa1aZKU6iAnbtjTzjSidus5vir40hZ2yKqqTlW2LzPoh1C69VtMAEBBERw15RijLYBO8UrX71TwvN1s5NlVMAhpXMY3YZG0nmLyCl0y8gnR9iV+T+uUiX3VbpWtjtLNU6IHA9thnuUWHMx7awH3V02WUeMCL3cMsE346GDD2lRxtU4pGOd5NW95k7MeasGycJMsQvDNobHlhMlqdUhxN795yBvs7O/bCl/pxM6UzEST9uyoU8zAFFdq2n/7t0R0UBqN9Y37rqpXTwu64jK23MN2tZOXWjmM7xQJdNcH9THWuwe0I8L8FT7rumqhOiWJRaxzPCXX1wVetXzSYmuM+QzuITT79447yJMEzIt1qrtdVxhRIUWqPrcpNqv7D47MINmvWi/YrowE20al6DM+AsHSeRCl7+V0sMvXa7WsYZt3+tCjG9PCIu+mdaHwF2GZd8YrrKjF2OiUwlCmU7a6K80jxAwWe0+zayxaaC83WBri0HtGohkeCQqbcCToELPWFNL7jjbOKQCAVXQkhtjBzikp1A5y/WHXbcixmpwHRxfxOUXTCv9DBD+9RzqZfpDwOtJtMUdQzTzKZ95WWurZr+QYqdnA27zHbLhvxMucGiI6ovgVkgXIxom9KRgoC81ZIQTRHClnKNgNy3zYiJo2eKazq9BpS65RTKK/XKukk8nVOsVA3E8L2ziIwfzOFoqz1VoT0DfKUSarkHAZiwj5lgls2t4ItU4RgF1eieiwKZiNu+mKYDTrX+lwdt1UmEvPhFK6VabfV+u0BdqcgSzEo9GDq814u5UI9wjc4fxOQpmgrYFi5e3pJhNVsYAVqlQodDCZUOngXwEXulXt7/Jo3wPWb1MKDWeznGYAAFBMADOBssVym9mo279mkO4dmP78AQfWJOxgK5Tg1ugUeZ1iAMu8MKNTytHpX8nsTV6q0VFtaoTNIh+PRkQva9XP4aEhA0NTTiaq1skk7fKiH5pODk3hDI1GJybe0AhbbQpbSSlI3dHxBwdvM5eUKEyxTRlsYck5BGcGdnLY8BdOhpklyDVmyAvvAEb80xdvabHH6atVhy8pr+ni7crmPZ9rBe0zf7vFsIAUNvCs4aezPerUO0Q/u4BNViGbh77IFsPLI+zC1VeY0nTzPzpWNIifN939wnhBMJfz8wK8V76Nsap/WhaYbzVGBppMDsf9Qp3/o0m/TSObjhUZVYaa0QW8alKqC52bX1zGpikTRBK7ED8S2/sa27Vp0znevSuyXSPIgl2RH01iMR7uVWumKc6VVsVHyKrw1YkEjlL6Fl5n7/1ko4NfdQVdaZcq6Vvy98QgFGiUjUd/T0ayerQaXRZ1ixIApvhqqGIBD60vYrcCWdna8T8qpQXw4zX7ApQ3TXtf4sUS0lyaEc9m0uC7t6ij1qqQy3LAyF4cH5XfRmB8erTZjKljr6VzcbZpyYRgRnM34TYIpx/Km0PnzYiESlHBqKU0DfXH8hImZQCiQFu1o6ydYqIOnevpWqRWkqcNNWV9LttwkLlG/bbO2LaVhszSVUY0fVGzEYt7OMok5BleRr3oJhMUONobLDjb236GF3SZswVZyttG8Yi2wU1/SLG9zoZOtlYQufcm4btc7XYubsxYgbt6US1zMjBwMmQt0FJSBesomaNLLzhCGFY0YCTIFOiCS905mV5WePVOoQ5IpQXfDvnbt/RU5E2VXOW0zc42oKHEC12pjZOgwgIOXabqVSyc5eT9zlTzTF6nuGPVPNCyj6Bh83T7Y5NTSOKHgQDOHiiAV5dpq82ZkXN0YzpwCz9Dz8jBwe8neiPfZHuthePepMluq0HWYA6yBvKRNfpTFJjfqQNeNj6C/oEwWyyhOQ9mh3BAN5DdbbdZX87hrylHWVWkTLsFbzYvG8APHpD1U2S+szZqTrZWrf1L1fnBVtCpwe6wu/WryNPfr67WShl8JPWx3t5oO2uKjTFw5+RvZ67Qat3EaMt3a59mlvRqJpZpjzlvKf6SjsP5wvr5stkY31sLvgVMJkmv9LCcl21VW1/n1dqxJJZXwpvNWSPufj/dZ9T5QfosPcB/g2e4x2+DJ5G84GGOF8o1J35FKcjxnJJrGSa815Nogh7N2UI/PP7jMmLUWIaXR7qG27WONilab5sRuQ6/Mets1VfAz+wew9XxWB5S5WRi1WmuAy2j/MOlrDHSxba64NJtzJLoeqg+7SX5x/limTk03L/r08uqZohGN9mxcJb1jZ76wYzdxfqNvbcBPnuX1DUbm7DlEtxcpDcbkrPZEb7Z9SscVjkxu14ld73+lTYDExVVqlheTQfMTdv9u1s1maiixe5Ggt2N7LW7ub7Q1/v0fcGWv77z10HnvSvVbtphGUaOSxG/G0EWS8H+LnaYvigGKJoe+hQ+EFiOHxPekBVKla2bKLVHfeyn5Ye1Y9qna3FwBWLB8PR8XagJrxi9lO+lm8DNegcmaa96GI5GS3vkQAxfrlMKGYD0F0GQyo3A4ALqhKkMI/JpbVHkqT1Zo0cmIQ+vpUqQ/5ckUKDo8a22q2ttgvL4yLmYQjej83WaJOIkcbFOMVwsgdDuMRHdEN2MXrfpQpkMizLBEkCiv9xt+RqwHmr7odMPSQJgKx4+c4oRWMMOVqp1U4fRWsiMWJ1P0c3oRiphL9Zpy1vITxW825/vtdqCFa8rdM5oHKdj2w8Ze37Iyn5rVbBCW2/JaZVX2sZHY07Uihlfdqyj6Ez3o3uQ4GDAIe+RH9xKbFTJ++WJLyXBdAxRAesvRuqL1CvFmwfULDMYj9Nf34JeHnlAK/pMX7Al5X1e0GE7dJYv2ApbCnnQuFiS6JdszV5e/o3v4K9f2JCZO3S7AplyC1xH6b2cpP8JcAU+D3tAv34bNANnY5sPbXNZ8ryTFukHMZYWkwzO1nFwSnTdsNu3uL5NtN+HOwFFaMPqMk2K+qa4bflpkonIkdTcSDw+mtG/5EczrRsTeCs1//P4SKieiAvqK86fJEDzBfTxYwHnKW2eekC5C4qKjzP6+LGRR6OSOkWrrkSpu8UrxzE5axVikprD0pNbKF35FqU/8t+QiT8AKkgd/U09Qjb9oH6unvF02y3UVdxtZWl3W5P5brsVJnHyCp4CuQOf7LkDQ2H+9/vuw9bQ5J2a70LVLgtU+usPddGydwVbv8Qr9Dkv9IFKdjsvv/Sp/3/2zP/ZM/+77ZkOgkj732NT/N0xfGSog7SjdWZ5cw3rZKzzngVaIAHWC7bODLa6xcfm/guNyudgqZ8/9JDrh9ygMpiYPN/iX3y+/ag86KR2KjzVvlS7udK5OGuBbxA7Tvu95kwVYrsUfVzHYAl7LWEyuhNBUx3F3ce1HgU44uQcbUdJliQa64SnlwoL1lf0VuvWkZFv+nr1G8iFEU+2mSFbjfCs8S5WsTNrNxvndlVql/DQhatQguuHyaT3GtH5zM2srLfRVTZ9bY1TkZYvXJlE9FojJBqz6hAczQMLPzjAoLpMx88aiS8o8BEjAInSrwdi/q9oE19LqkH8lWy8EHOwFHN4Iv5DpxIvlUupFe7BHwpo5wq+qlLMiL/ztIZqEj6TUBeuQDaZfNWkfPB5R2guOiTwKwOIIxe60AbKoAu2tIGbtmAyGadjvYWPc4HeyX+CyaR/v9nwhqoHaJLYmKA2VgcR7Nm5TpchNpEwk1cudOK3uubhApOFA7q2/eTklWivuKOTyesmpf78WbBl7iOMz9EQFkhygLYgk3+gMlOQCqI8z9G83yskElF/x73fdTtZVMucF4XnNNMl9DfszAYA3KqKxRUhrKByjH62UxTuIzhU7bFyWtRCsL6Te0a6ixo9I8wIxKW2MMGQj4lljHq8TvHicBlBD+DCQxQz4Fr471vQAYn2Kcfi1jtG9l0zw0yMrbS7mUzoOM//1qQ40qo7lZafI0Q8UEZGF9JsiQvgI9XTJOrxyIh7BeKKAz1BJ5MjjbqhKWfM+ATAsvNpcbhUG+bpOjBEiHjYqhMLJSVqewA8NVLCATvHloPt3/ZdYYaOc/NLOFaLyW6Ke21fxaPNJkWeGSiUKM2BfxqKw3H9Q5en5oBPAANZmh9CkjNY5fJqOhsfwUYflzIuLglqqsftjPw5aIO06qJ/MWdt3YZqpkPQ6RwLsoRd/jc+uekSwDanf+4P6HO8oAcK1FacyPlCMKqATh2xq8u0m0zaySQgemul1qfHVrpoP1+n/Ixag75p9CD/41af5GWCu62X4mBLDg50eA5FnkOLPMQlD91uFXmh8N+XR+mpnUaZsF1LUwrpVCM+hGT1vEBQCH9qZQe23r9yLvcHC3CyWzap8B/rtIKHnPEZgVE1+NCCT52HdtN3W5CZtGNvZs5f6Smp08zFJOUVZeabBUdsrwjbChwMWStA7blId8HaqWljYvGixeFynqbMci+1Pbv4Z7OC0xRbyTDI7K/bVAy8syNRD2dOhbbGwhKfLnO+7B0IYN7hndiEtnqMiw+iJLbMkbWfIWc/MxQ1RLZWf2RaMSBMoIhZmnKBB+sNL8jSts1YkGW/6uTcfc9XuvXaMzShsAJbNbrE2vSogviT91IW+2ASFxLKZJAcHEhlnOQzf5O1CbRcl68Qw1fqyaQTNXVgnrr11PAFfy3Kzf8IsuCzYMPk4AD0d862n4yh8/voBadv64jNbECTSSrglV+tXR9JeChMbwG0DiUv9i3cXJfiZa4EK6uY556dzgj15jZc9tYnBiWX8vp+jkBP2GCoMoKgeb0wv3rA8i38ah0LW9Qr99yytvDrezSQqgAp1ps77I4a9AbpD/RSmXwbvSOhNwVdyQBrGsOhwDoUqAhT2uYaKq0s8DNU+N9iokyFKzaErJlbLZWHZo3qy7pG8EmhYpCBUrXxMO/K3PyS2TJ55QsX6mS99M1DeQtlMXvgSFSt6ZtQVyg8uao9tl4qzUSHn4akSEMbfCcagcp27GUS5vxH2tg88HVXGtpnBSv2AWzwmvttGh9S1dS6iEM00A6rwKHiENAxJHxG4jjKBb3qHLyC/I/zSKkf066QN+5lkR4B+G2bMgBSDLZZhF4itXV4sb3V1MHlgBNNFgZSBrbb+FkTaTP+rvbth90hjwjewjdkYOb3CMxOicf7lnd8f2nRFXGfgfYH4Up4jw0JkWXbCw3ByrcosV079Te+36xQjRgaBenlfl3FpwmZrgwFRb3HePWStRZ4BBYuPwQz9JlJZ5cIOfahhGoWrHI2Z5Z9HKxzPHdqcTsAjMxdTSbOpVee55X9rI2eJOMS4ZNPOyybdYxXavHQNq0gge71GY2lA7NuPjAx+r13nVIAspTI26FKqoWIe72VV951F9zBWznZSL/pzOt5baaNIEUmjPk7A5IWLgLTuq/Waa3I2JcIK6B0U5UqY/ccYLAGA5uQT4fd/RKjfX/XvPk1PI7BubG9qVi55uytLFqkL1wzrdibibdSQ/aWWo4gT9cFvkImoVK0bTZCU7gjloRdoC5DhQbyyvJceXYSfNCpDtJcmKdBs5hmvnKLS/H3Lml7CBz7WWsNUrnsMiYkvH0mGrGj5wgbWR0rR//qGTFazVkwLyU3IL47V3xf3y079Dusn2+XOBDWldrLRhk6cYLcE3Um0v7jX9T6e+WDvvHCqXEhbjZRNNI0M/GuhT4WyqQDqfhnv+HislQaGgRfTb4leCh9Iq2Igj+Z40ggI0deiUn5oUkRADAmwA1R6QvVfD1cs0u3AelR3NvYd2/Okz0z5OaoW/pQR1fGl/w5+SgclVHg76ormTtPwrNMnhRARu0nVRMuUtcpdud6iBvfayrYEaVm9lTv49D2KcCUIr4xoHTQHp1NRQDWkgVTWwC4+1by4SzY7kSIUk0T3rBtmLAXC3vCU4immKwc6hN38Vf1ah6+SrE1DsR+8sdB/M/DXokSIQrdutc8lH5B9mRkcjLq27n5He9khqCkTca2Ee8In//u2grFxuLcT/tt68txGkZlw7SX/fzblEYdtZUtlj1SLBikvo659yyFEnEyhtgap9hrb8Dk024mOrS2lHSUR8V9eVCWKYQ5PDKCKUS7AAKRJ9BidXWZ2zZfykJOVwCEwBfuh331u4bXjQg2U4o4GkeEUy5m1NFOk5wuDpc+XIuWHlO0IMsBJ3sx81VGpXslQvW6BRqIuNduDU0fzTe8SulQpVo/LpyCoQRGUwkHseKqGD6DrmyQuv2MRu6Mxnpw5uaXVvXo+Yu9F2H1ouRo3XZvZSBui7eaS3sVrgFhNmMzlpsLZIPuYK1ygVY9mXgYQT0QkfPa8cVJTcdTfvqUijgDvpBFtHNAgEIgjYr709oLr7OHNaIVhsxg/Z/fNr1qUB5rmYvi2oO6amWgPHG8xGtEK4GAd8ZowdDVrbZOpKguWPUJvarwRzEdOt6YvIppBSkqyRV2lIJAePpIwfQPypDGwWddLKFRP1oYrvFqgQutor0F5V1miGKqcUvhmQjd2TuXKI5wSRH6GQknD/eNYEVOWyP2Vz4irPZUiY6LPLGG3ZeeLMpJRbiuMO2Yct6Ty8I2UNe0YrwUDBwWjDQlykKJy4oE9O5Xlg5/J3oHl1q8w2Wsnl1yplTL0PxMdGTn/AIzbZKTu7SnxlJHGr8En6U18J5OVHFSoUD3FJlDu/EXgwtqFgNQ9a7ZBQvLIpNWVGGDLMSbt+tcr2DdIfHiPrn4UbG1ooGjjOyf320hiZJVBS/wFYMqdoE+CfwCg8FeEfFLcs8CQ43zG6KtR1rHfISt0agtrpGOco+LaySAZehB8kgEHH+UHBCJrbANOpobJ1RIpi2hbEAn7eSSAK+PjzIWeX2UuYmnNSmLGnHmUVB+GHYUmLzeXRN3SGUKK8cBtJNYa23eGb/PVvp99q9kziJXHo4iv82D3Iod6M9CY3sYHsT3aBdm9ae1Nq9B2z2gv9rJRDVxMkmrvOt9RStpAdrthv7SZksR9FbeUu0ou7Rm0k/r3xqfdZiEkXH04vwDu6F8/aU2IgDwAjb8tJahGDTO8WJpYS4q4A4F7WFZmAojKOt+NLvbzojeRjFsv8iu+Y3QQwoQNqMfQ/DHdcoA/Jb/e6BbBL+XsPvmKrwIhsDD9xDPD0f3cAmn7GLuhbGwybTd7gTk8CFg9PDws8DrJrWgNLy7FmkCoYJGKrOjAKLjL4cyRjmB/adFkOrxkWOSmZHBju4LDNIToBaIeAhiMKvzIkTM7IzZUNEjZ2q552Sd1rCIxFn7jadZ7U0zidYZ3YUMEl3/M0Mu9hxyTwwKpDNbLLe8HY0QhoVLUblT4IXrvHGF3hV/4eIJqhPtyjCdtWcsJ1bLZR4VSUpoIukslBBK4CVYaoOV0oEQXLmn5j7HYgmWYkJexYRyXgtccTk8qOoKLH3/uB/FVmCd4mZs+qElHS01GNQM8OOc907vTr31x7d+QRCLbDKDMAk7W1eXbB57mR1GqsUHIvaR9x48oEwtZD0+siI7OpbHIp73rwBs/WsP2PpDANiqbzajMK2OxCDh8DthBEYh9bqcI/HK76DZ+Rx5o5XooVyY0PJGIeWN/pWst8yLHlpKsPJSWev8sE5L2RWNM+rYEM2asIHNrgbCbiGKXObNPgJIMZmoNgsBpA0EkHYv7NFuq4DR49CwenZ0YWe6nZ1xIUq7CMLs1jMv/DUTy51MbWh6GcwqSGBnR1Dw4GWbvE6pZHZ6gqzlBOlfyeyrfN1PENEgDFdgMhkTPpwrsNTMzp0dlyFBL2METWp0VZS3fOJ188BWNTP0LlVt+aU9edqBycPlwLWePEXe9JOnkJOncSZPqyZPGwOuJbAEW0NWy3iSAAt+Iuht+4Dp00YQbqW8FQ60NX117UVYe/GA2otI7YZT/vW3w93Kh3C3fhjE3TJJvnGTrApWbDZ3Vru/X3v+0UIlKtII5djKVQGy1YMibEvLhmeIFWUs+Nj4yDOEYIT6GvOYqcQx27NAihit0Cc0dOcZtcNAXYvCw45NJMc+xwcH2aYA4pWYkZcoTU7fvj8/OUsApEOkcy0paxn7CvVe11Xdx8IiApZX3OO+qlqGcB8RS346wSvzgcaGhJd/P6bxQF3qMjjyhYurpv0yRtPzomSE3qYu+HH0xhCHrZ9MIi81WD3hhwsBwulFaf/YpKdNSoyWW6Icr4C8LH3TAEhCwOegybsNHkN4VG3uWNswxwBkr5oUpSAKl69HxlY9/MjmL9oUgexbZZTBR17/kA08bm9xKWO8aS098ZZo9UuW6DspFbvag/5CLnqzGj2CeFEXEL0aWka+cC3up++06sW87lY+7K+C8HVjkLcrp3Rjdym2h3tWXo9jJKUGMda7rzHcmHTMVq4L4yIDsFCTUpheeIHqFGACNqDQrQZzEs32v75c5SqGHfokIGd5YqLaIvbiFwVecT5Rr5TZdVFfEnqNVu9pdWIn6FZO4WiVj49UU4uWnXUlnweXXf1ylT9WH9aEfGzzuwt0SSh6R43pKsFZu4LFJUPUf9sfhEW9Fb4y9ze86dXKMjMXDNf5zFaapZ0V1+g9rXvw7DyprjChKLnvmsgCLTFted+sCmYlWaFLRClaJTuvlLTo5QURJDqIoM7cCtOyy+oq7UBvPI4w0xjS2q/ScTG420JryGlxo1NHSrCnkIqRyAujq5TP38hybKeMVldXiPZ2O5+E3c52z9S3MjWwhks5kD9Vt0CxFgbLBjjOff1otmnUIVHQ8jRYe4H3w+Dy9HFALAeHeEb/ekl4EVizzr43VPaf75tXam1Lu0izR0lXwWAFq71Tr7uvboWW1+YRQupLx4cA3lHU1EXJp77ASAjskYcqH7C6c6o56y7aklYiUqpGd4h9y93GtfLTBXLu6no4INoi0SPpP07zpCFNy0dA6jh5y+f9uyxZF+26lBalkORsKt5PJuqHQ7r5nf2UxZJIU5tZi9h5dY1Ix2xTAjRtyzXiq7Yf0lQy/pDSh3Jv3QNTo6P1biSNVm8RZqjd1bIH/ojjp2utznAxyJ1BOdqHBimaOTkZ3/ZRytXGhIygtP8u4V1HXL3Fz1DLKLkNls2qahvSotRrnnodJI/NSh1LOPZt2uF+lgI4PLMjPhnDQTIDPCzt5igsNdSecU4EBoFtSM0ntVHz1jmbNnwY6Ccbnx92bia9W8LCSv9cFTK7xCmYTOrJpCS4JTUyP6Y3BcXuU5pEqhtV7WiFGopKPqZw1LVoFKldCKWoWE0THRsKK68kn7HCJi/mkZltOp4RuM61d0MHlPl6p8zXhXyYZOu815175dgEpWAmfZClTbrqHs9+T06VTdutr3OqwjkLF4F1Xke7YBWQqQwz11JyPZmkaxPLmnxCIjwjZxZtugYgomwadKZ9s05VwAj9RyRXgUA9s6LwBLI4XErvfOR65Av3Wdth9xnfYIRf40webA4h5mtbxOsKwNF0iwPfU6od7OUFIPUdT10nXP01hlEROU0hAdHPhISfoS2AbYrgwkAcVNul8FqlNlqGCWjGkzpfllrE0DUZz2M6l6mXMiYRmfMiTc2hnYGgxqFwlU2mIijjZpOqZ/E4x/n4MEum8uOcHRxkSTLO6WSCpB8BFbIUApmueAsXS+cA+0xYqEAKtireSqXgGXpogX6quJKkNWOcO+D+lraHcrCnxKkpj88MUeljaWpoUAVdFDcvs52uB4BThcnT+rFws+6BIcD8MDsKguTyNVL11yJ1PlByN9y0AwJbC4a/h/yYtX/ppB91+zjv4Dit89rgtgRWGi/xp6KuViNZzohcjh5Np08eJWDW5bWvfN265Kjh+Ah2j1uwTcFWOPKL6HG1f8E1/8c6rd0rtFriXIh4upJWIHu9T6pZPzW8xJ2aFtu0jPFXiOAaNn7AV1tEvWcrbD9WniiajY/M/uioN140c5TpU5sUFhFQ1kGxk6LUHmiDrf5k5JqcRSQ7CpPqukFUbMyJsnAb6GNcObFnL51DVH+bdzhjPSITOzgwUvJCWiTxBuU5Dqfd+RqNKPqpQy1DKwFTNioJZkWF21FygA8SAzxTsJGYBKPkQHigIk9es04Xbthz4QjrE8OWU2NanVDl0WcJZE09uKESTdyssDxSmtToIG2Yg4FONqTGSHFEDwOROU2yqHusP9p+iOUXjWZt75vo6VYYSVhWxtZEnu3OiQOi+xJDjPCuhXiwQdt4cwu89KQTaoFDUA1xQAFkWwGXELP4sU7mu06Sltpql78Wm6doij6jsmPoTC3TlbVOmYK6u65aNJUjb2sybfdpAGLnTxD0I+QGuyN32T0xt3d8P7cYyFiwAfuNQGGRV0nCX1ewJssEUMhh/aOeVO9UV7Xd+Vhutrw66zAsa7MPz1+4Lqto5lf9xepS2DnK+Zn/kVf7Kq1nnljliJ+QuKiXHxwEqhOH4dtDJg67d9Uqa6Fsdsag6FuGoWx9hqBQV7cZ7YF6IUV8XWU1VLMv67YAdv4c7Ndh38N/iJDYgZnu8CzfZZZcraTcLVoqLE1lW2GV9zjCda7rhV2O1PAIKUf0lJ8UhzZQpahPKYBlPnYP9JtNYQ2lwQdwj0B9glmaUFSTYpVo3VZEObvZlECpuWLN8a8aUgrmaYKKK0QT3YBAS7vZkGm4/arjaIvYV5TctIiK4uB4TKa9QgdiAAPVCJ+EXaP3D0dDUwDYwRYA6E9oMGVrhON23LTDigAoLaBsQtjeoGVQ8TVZcgVrALJS0a4XdR5CTF9Kmqe/f9+P+H8YPl2nhTrHumrgHsfT7bnf+JzCSnL+0PvrTUxyc8Old85lJhlHtLED1ClMdEaHOghAK3Lo6OWzkbDFHlXtCBM2Qj91RT1iRBhxqyU06msbVatREnK1CLHHRwBkUTbZwkIZIsEmT6v5iza9K5qmrrhoxLmcpmxWbWURzTrtzG1FH3O1c+4PYOeLUCYBkPEwd6LLxIfAF6LJZJISB0Uemm+VsFrSVywSQeu7tVNe777DD1RdxIelMy46sPOUrpytD14SwW7Qn2fYT7ALJk3DJ00XzJiwKRgAaI8a60cNb6U3XEhtQ9DkgpAaFbhXlYhpUIGsk1d008gNXVr1SLmuFp3AviV8zWUI9guQNy0882BoacvpNqSS67UXdyOuLtOwJ0YhgWbaQa5vndgrdS+0S1spxImv1ynmo2ipJU13Y7M/wsY699ZLxG+wcKTMhJP3ursHMLZUov1lm03nMINxnhPL43N81KuYLULQnPmE8NvPqbLea0JiACkAsLTxqtJwyNgQpXhNq71rgsyb/LinHYXKrkf7MrOtPX9irGdPks4lLTM2dWuYTEofsiqNdO9yv5VtDRE/0phNjhPXwtFKd7CiHWsp0q6rX9suprELWJTMu3jOLjJrRhTaBPx34UM71uX4aKagLCEVErq1MIU47swwY/I4tyd9pY4naX9T2yMqS5RfFtihpVg7MCqnq34g79IiV29BEBlLZVM6WEfNajtvxwMs4mEPLWphlT7IVau6TCO9K7xeQdVuc76UBCrA7+COZdcorInDAN4XXLgl2kmeGRtDPUpSa68FUYXe5eu6VQ0CtVp137IiFFahwdsdoZkLYRA5MtBDgrB6HoykBnA1uqTkelSMVtXlJRIiqig8AXJcPCB/0Qbv3S9uwU3F1k7NvWLdRBQBM91nfx4rCs0szOQZ/XPQ4tnBAQXI6smCLiG2n8CWSwsAdltl8K2D5inbq7TVdAfSikG9b3vXX/3CCQ9g3vbg/+aV9ArWeMjQwtqEvd6e5DuWoTcnoT0J0y5iQwVTO0ACkO7XMMW5IyiBOVZwllIYBzoUoNyqvR253WYxPiY0O0HSLQCzbuogdLVp48ppXGh3VaQEaqmfH3Z8DYtbWvTwpyMh9QclcQxEUY9hm/2P3UD3nqRA8zxvPFMepXzp7V/E46zxTb6cTaKxT7jNjisPvxhYAZ7Zsr7CsDdeG+eyMF9vUm82jachsVsAO0jlmJertIlNIwxZTGBuQoHZjI4oyJaWy3x8KK/Zy3x8tPW1CeCunKeNbWZyCJvQxoTCJjh1tU3KXzsSDwH+G5+UgE/tdHwIQMbbilokvpCnTqoURCos4hUmiSzyyLeqqy7TtM4RmEzqKb7q1QdPudzHR13wUBD0XjRKDPMxXmlX4OoBLULTa9S2xRXSDZMgzQ8puRwoGQAhDbRp45idCiNBszkLHAPBYuuI6Vo/HQMvWeWnv/u2yTVmm1atGrp3BVuf/NQV9TlJKdhsVGQ8k1CJjKL7KRURXB05FG8VAoLJcUUG0kWMqyyqxoMdeMF3IuahLG4COswmovdMtjlqdGZHGh9JN2iL5dJx51j5GsmQllGLMh1IG5b7eUxEjIiRDeAjaW7hOWsWKtM4SNQxa9QIUlcEUVoqH+RWi3O3rrn7aKFIy8m8shAcNaRoKxYnAvCtMrS1q5F4KuL1cM4hPE4r5Y4VCMl+iL5aXWPDQcyoD9DZpgiSBVvy+alQfPmjBO4lPnDv/Yi9gXjg1zfQMw0FQzyEXhEWIudnPWFY1MeV1EEgHOBQjXoxC9Fl7WHgNfexIBQg7T3psWTWI7Inbq0PyPIQ2NWB1eN4bRmkYiNOzlW7+NdjvDpjhMq6zroLpk0MsoHGvxWEk3ixXruHyos7K+0AUzaIWer5TkfhUUAmsqpUBgkxc5tg2bYe3W6VgtkgiXgrA9rAOzNxTtFlRqHImSFYKnkoIwGU0RCNduIC3tN7c8ctsXQrszx7UNz+DJ+xWWwNau3AfUuxEmCoBgjXLA4rY8oT7Ca0T5XfhldR/0zCmVKAPc5bG8Cd3jThShC2fP4pdAgv9SJawP5HnH042Nt1SgG8l4+9pU+FRiDkZ4M7yjAru4+Ree2oLtP7WjHkGuQ4f1pWh0rNVOdD+YyGxspzz8qmljZKeOdU4QQ+RbIpaCUiEesTTzWVupBTdJlbEYpP0SVUyqC8VjjFCi3eLB79S5WQetmdbAA2vF6F12ygZ7o8bpNmWUz+JsiDJnE/1LafrYNLKLSG804jEpocyvtSgzuqaa1oRjn1NOxjGyWamonfVWydUtjuEJAU7N1DZrTIgIHvtdgIr8W3Zp+MAsA1K6kuXN/riOgcFrxgLF7MusUSKkPCyYRL3eyYMVpddAylZIrFpeZJjYTBbMKKC2EumMDksI8Bt1fMZd6QVxX+mMC71vZ0QX3oGBVDTwZcm4dBB7MFWmaL5ZcJths6NURaJh0lvoyXxHgfNwnt3ybLytHDHHsIflpX5cfQ5C5meHop4zlHjEyAfS2ik/WvwNaxo5JDG7MY7bS1I4Djw309oXiO3d5QqkLXHtWZQ/Cud6fJ+jzQ9sQQr22vEONpIvdd7XATGVdDE/0NwMioBjUYnxzfHycoT3+Qp5P7JgBnhKudHMGWcWb3MQbj6GQ8aUOGISeO7QmFtOonYl6JwJ1jHts2nNN0Qs14XtAroTg4xqsXFF2mvM//w1e+sPfVr2Mr+Oqt4gxt6C44OIx7O/O1g553293czYYOPBznOdps2GaDNxuqb1oPZzEvJ1ErEy2eTJIPLaovk3Fuve2zK9S6fyr7JAD6eCRxogeUXfOX0UXN5wIX2U4+M0RxUfeGf7I5ocdpp/Xe/8PIf0NG3guElys7rHIuZvd4jIT8d7WKxObyB1+BsPa4zJLLW89aCu5faYlT3Gd+UugJ/TFEiN18u/k0jA2ixk+jV6Cb0euiialD+XKpaqWlkEe4YUCZ2EEPgZnWxfRCrayXi7FSvedzkL5KxY7QUEgNRzcCZsKDxyZqUHagjoi7PphGOmzApxhE8eL7w2LIik0ZKECa92i3X5d1+zablIl2Xa2iZJaGQH6VsapiPVZY8cqTVoozt/secOSx04ClIA8shfkzXU9zzqefISZjSRL3gLeyFsSHwjFEsL7oDyc9kMo3qrpeYxX5iItrlNPN5qyB8TWQmmQiQxTYYtd26pJkYM73lUQ26pe4cqJ4V5fp2KWQM5+9Cu0YeKaSmbgRFxxIYNManjK3WIz9HqrUSgPsnMmRDuloBlZOHqH922NzsmJrDW1QY6/DX0Q2NAqKsNYIiQMbGTmE2lbcJExcP0bzfqol7i/Sdncd/JYd8Jbcb9D6ZwUrdksmXhvmsZe9ImxVsCK72z5MqF55YHa/loTu5aq+m5hZ69Skjs+X+7iet6kUPnaeuQnqS0Tx4ryDJp+oiLIUTdekZX+r0M3gXZRHrh1Myay1mbcqVpIFpuCXMH2fs0/RdSUsV+IKeM6tQldRUZLFgwat4XQxowKPipqiYnXbD7nC99cj77cZKbPvlOVMY24oZmmiDj31FKZpYDLnhokyGlntbB1yfl9G63cAC8dT7IfXK4EL4c8EFUDGGzUPQqhUdaj2pB5GmobdJCC23U+vC/rxOaEiUKA/DexhHWCn2qrg+h6ViyVzI0u6NrIKgxYNcxzb5q+C6zudKM/zz+t5X0XG33xazcN6MqsWKWrJO1PehQsP8u/DwyD/GunJNxA/S7sArIqIPbXlkKvacvMF67aiJfOin/4ydbmejCaUkKzSxqAjPVZlj6HGy4x4PaAohhpzrL12pr5tVFDhGPoiYu+bd6aBu5yu2wCaS53DlQJPDNrP7b0ok22zBbCODa4ZnXR/h+tgPB1u7sBwfsdcgUH5nPd3hrZuQd41fXlllFNpPFwNJPli6Ri9V7n0JMsrY+veSVv3/pUGj+x6W/fWAT4VlullISBNJ5PWu1UzlvLurRqRuDERehXq+gwWCsJfRzwernXuliYGTiEWItgCkPWKhMlkuGYEWwsa3DLKxwNG+d1koug1maQ0r3qjfCqN8ivHKN8AY3hG+d+mRLGm791YcUiABUTnZYB5tgPvNuQTZj1YdrCWaYQD99r7mLFdgK/MHeAcQeyTVw8s0gO7VSHJOU/8fN+FgYGMnkxSnN+50I2aRX6q0E1DKDsrKalteGGxfnrw0qJlPfSosNMT3ue5g6+ihRRGKFr1ySWY8902xvYq76SarKqWi9sr4weuWjJtRQvfkbbiz6eiFiEsKDsLvyeco76oeKpb+crKkibXBe6KOnFoIkWHEPhQCiuyEJlGCx2t9S6STwYVcTPGsObsFLujJUe4fRyNkdmMvmvmqcLUXiA1liJQlE+yK6R+azKn/MhjDTezrN/P5fYmD/F6yJl5UPaO7rNjPJ8dgoz510qpbmDOptUK9kAeFpFSppcE9eAmjy8ZoqcKIb0FvRtGYCYYGZzfgvRPG6F1bBQ95wkjjYxodO+8nkcGSCY+J2Z8FofwcAmyBGG5avYrejLZp+y+2SBj0wKXa0Ink3hV8qssq8JXu9p+LJKmukSQOWv+i7VeUiYY98h0GjSGpKEI97RJEXQBTV2OOO9Z3sLjh8tMAVA9QJoZ4kwaIGLgcwz/cohZqaKGPgcyFN98zjxY+9MPT9++ef7y6/enx+cv375JADwJUjx/e3r69u35h6/fH58+SwA8X+WLp/8/e//C3ratJIzjX0Xmv69LHsOKKN/lstpcm/SkSU7itKd1fbKUCMlsZFIlodhurP9n/z0Y3AYgKMupe3b33bdPn1hDAIPBfWYwmEnJ53lVfsozOvh9ThY1fTxL63rw03xpEtKMJ0gRd/AkIxmd14PTDwX5fU4+ZeRxSl5SclKQt4wUGXmXkdMyg/csb+gZOaX699mSZ9d4r84x3rcKb5qdocpPCkPVm2JJHmfkMiMfEJp3QN6PYH/3WSyOkyod58V0sBEvl2fmRuhFFlrBLqdFGMBZXwUklZZBH1cc61iQmpTV27Jk1mNOhfyzeu4+oERSWdWD05OMvMo4+6pJf2r17EPVA6ep6jL48wp6ztveAuJDmLQPKUb4RiG8SAmEU3pNw8s00kPzzurpK4uY12Y4yFepk3UEWZ9e5TXj3QzmZk2mbej7OLjMEKJpQS4WM5YPNnq48hfZkpz+iMeYefP9oIj80SLvpdWS3/yZHtoodWNeZsuzM1BHTcrKCVTObhlhGF4obN1EvnY95xdytb+eTGoKscVrygQQ2mlisK4UAuNm/42L08NvFt1FTZ+n9fmQI3mXCoNwUJOJ3wbdw0w+lKJNZZpYItKBg5z3YdThAgPNOuwyH9Nu52X6x3VHMNQdwTbXHWEmCtYVLg4RVD7C/m3lTS2EbKdZYGh7hS5yT/X4XVNr/MR6oGiAi8yb4cwgfpL5Hi2SMWLe683NsNZ+hkVEqTQLxUGCSr6dh4sITL7Tzc3Q+6QwSSMyhkTPO5lxROz4AZDRCihgp/P8bT75oGxr3IH2ckAD3kAFH3aefJ+G0fF8tYHSeXdWTkW4WDljOnCYDTrBlmD3WLUAFQRoMwnkDy0vZuqb/AHInhYZtmjyeruC9vpCFHhz81a2en8AVO2xDFaFKyYen1lqLjjxDjw5eXG/CxwxZfwREdqjAqLQQ28zO7KQ4zkajr0fW489yQhpXZ7W7eUM9bRySl7RejFjryeWy4knZUFloAzvs675/IX28tLmOB9LAZYya5Q2nDeJq8zGA1cZmhjMh1tc4BntQEIh6Da1K0szEYfY+vgug4VPu3n9ErwnPZH8dFhGNzfm89NCfY0YuOZTZvmGAQe/f42gB1F1S5gDgw5eUysJYcOPrdXJbiNrR8oCEP7Yg2or+Jpv3K2+RjxGNtSZOUOlah6EblKy0RMtEyKuf15FS1I1CTPRLBqPREdlyWpWpfNmpAbblMMdY/WY0Pr+ONN3Odb3K5goze98AuWe7x+K6JgmSZKbS6IaXImryy57CrFo6BmOUN71N+YhizY3y1vmUOGqwOGxEK8jjEjZEgkkRPRyGFxK37ITyLfNKNRKa06Oe0YZDV2RzekPj4mMdGT2wZKWGz12c7PRa0vRPIAn1U+N6u8V5OCV7qcnbq3R4il/sDd1ew/tjvKCp5sz4Dc7e2MR6BJ8AbxEsqM4yRHuICLvs+SfVfiZFuN0Xi9mItRQn9TsegYBbIm6z0f0PscE/J6HPXIa0jAKI/KmDHsk3j84OOjH+/J1B/8nVsbJ2/KilsiHFr5/oohc5GFM+nH/6KgvvvfIdUZOP2XkSUEeMXJ6CJ/PyNsC4YnOnPd2NGQkJr1IRgOCDnmWJf8ow6CYbiMLlKu5zydDs2k9u002kmaTnmfkfaaas3sU7+nWXM2t7BH+vSSf4f/Ts4j84VxKPnLg71ac9SjGmrh5LqsLGPfsVXpBjXGd1Lr8cS24GGngMNSfwQLKE1EA61e65zTlcpOx2FNO/38tfF7/kZMPeEPzehIGA+E0p/i2Z57libjRPVLwLbjqsvJleUmrx2lNQ/EEU2QotuKoy6r8IoyOWfcivR7Rd5S9shoMkQaIprR7ntZhGQ3NB753l5G4ocmjgUngolxJTvOzaLmMloOV7XacSzcabvmWhseyVpuOG/1cwfXOaXXGt3ATJzh0yat421paDuFCOekwpg7JPjbuPPV6ztbcotKD4b6kdkuihg1k00ZToDpGBzUeCxeh5hu5kK2Dn7PTnlAG2vXxAfCwLLgF4u3DpCovQt/6EFeOta8lD2ftHt193eNrjTbxtLlnWrSZEMA1yKwsaPiZS10DSsQ7VUbK+SBIA49XkC/CVDcwCd8CX4QsayDzT1Gf3tgdDz7JWCTtd9xEvghYwz+DeyXmbolqe9PxjySMrx2Uo4lyfv1MzxWVUXk3kaCOj6S2TWMtZTZYXJn44n9Xre42wWOsyAh+gbwbtjtLFbltUTepZxVQPWFh+4r825e98RSEWtO8iPg+5BsdntP9Lks0LpT4fLJUdeKw4DuW9vpWmF52xvK2oVRJMHakwF3pjszNzelZ1B2XxThl4Sk7i0jRWLJqcDxdTUFB4mzxMlwT7ZZzGbEpDQbwtw4G6lQ0YdHdA0HoBE+LMxESz4l5JOZ1yzlApSW12HKrJAxSdfU0bGxYLFI+zHgnHFdwMEr3xRWpxUjjQmIJ2vGkMtGiEreoVO/mPVXy9I1ctYW3L8yTvDvJZ4xWnuUBMXVKzUMIP7OiQ6QzaoVfbGI6oq47E3VyNPA0KsdPme+K0bGHlGuqbWHe5YRatUyNg7uWVUeYu3C1PcTvdzM/o8W4zOjf6bXvUPwpawQzEflBibtmiYyuqEEkvn/7wthA+su31tiGwZLSfrLErsJTQr1rCx/8n93eg2lOgv8I8Medh/BxYH3s78LHr+yPj+EjsYs/go/Hdk7xccvO+QQ+JvbHZ/BxaBcXHx8EQjj6ZZU4oWXozc2Qaj261JyLyasMesWTvBo/puJbOhxI5pvoRM7my183N3yH/z0jFCa9UCbLMFv8g2CuW02E6zkd55Przqhk5x2DoJMWwk2n5M2VlfBFOk/AqaPJqvRCkh5SGSEJ8d5MyTabK0QbhkWbJODyywJCgLHhaWEmNHjBD84G9jct97AoIgWevjqNbcVRdEb6XAwqT3tnZJaUp/EZqROhhcrFtl0LeWbGpQe+l+WkBt8yckPD/So3TN4tXmkGD0Gz2Shsqcl3ys6OS45R7qP2c+MiGhYDfpAt1a4LdSPXFl8ik/DaQB75MgmEFxePsLS80SZj3EESMFh9fP8XCCscodz+v0yGgMuP+xEifKi+XIrwYWuKEeqqaa0rBjMOostsb7Bo5sp1b0600JjXUj2IrIlA8aRbQRJsuXjEwoXwHL+VeQH7hvV7feYXNHUc9QDvU0vjSxlttPa+K+QmUui92dqpb+VzfZKU7GvhMEWvHiXeoH0kIjJ6lk2Syqk/WENlvspB82051thIGRCVNCOm5SbZYC82yZmzFZy5ZJl5liGaEeIu0eaYC2nsa3zYaCJFdlK4vHI+CU2UPFnusyin2ElZkyi4VHoylxBOAGjM1BGksB1vxxsQPERE5RzTsCQxVi0Nm2RW0cBLw3LpDlWCXhoYzukf+PX2ohBv0zLjIBj2tkeLyYRWm5uWWT1KMfrvr25B92hWjhw8/JNB8PdbEDwrq4snKUsdJOozdPrPt7rRBLnHcETVTNkDj8rs2np5Pi8r9qYqpxWta337epmz88cVzWjB8nRW41vZeVnUFCKzB7/VZSGNhS8oOy8ziCX2fj7XSlJ8OinJU07uJ09fPj15Kmf4d09P5K/nTx8+kT9fvzl58frVOwl9/+71qzfBQDvuV6F/lYOI5TJElEQ3N5VkKaDFOmxeMSyE9V6ZVNGgTApSqp3A7QsR3wl9aumbjdL9Jq65dE+ZClDv2VkiUiqBSOVWmlKdwPMIqwGVRUCJ+uzIxCoSPFa5fpdFBBW1hGHxCUcIk5GNc+MsXkymn3J2LhwwJOxYOyqbJcwwnUPF6DrZt0Qk2tkwGAaD2TeKs92Oh8FmMAiCaCtfInFXtpCT/ktGfAj9b3Ckz4xHfOw9hv7o0ODTY8g/DP6RmQkT3dx8ZYN/t0G/KxNApn8N9C+8kn/JTA7U2YNGRGad6+bGExvFJNp8rSFyyJdMV9CZT3DKwEdAw3snHYsHheJG9jnMorU70+ou8cnqUNwH13MqGFN7CESpFR0dMHrFHsxnaV4ErX0dgLt2cVf94Gr78vJye1JWF9uLaiYYmOx4fJ5WnNd8f/Js+zBYPRAizMHdxsEiATZNDz/v4bzaY9SLTU5qowUATkQX1Ux+XED4QWZtMub1qf5EcrM1Mjl9nblLZjiLs9MNG18Gvk2SLDAOe1cduh8Gnt2Y1Akz+xre1kRcfdgMZIIAji1zRqi3puy53mPrBMuXOLEZlZUi80gq9cm4BIiREGsPvr5Rm3TarEMGmFi/ClFA1JBGwoyThhCwhghxpR6kRHbGoCZOXy4IHu5BSdzhmmnF2/c+e4MOPaXdd7RgSe8sCd7BXTP/9H4+K9NMH5bxWRLYn0S2t7JyuXv0z5LA/iSyPSkvCwvfzlkSuB9tjMkuwiVpqmmV7HFKakC8DD8vI/LPlS563EdWYq31ez0U0U4ovYPXfw/sAzahZkqKw1W9k0rZojYznsovQ/VjwHDGE3rFdB4O3NyYWMgJFYvasGzlxwQV/pbTqiz/4cs3O70euAbCbqgoYhPZys2Figd8IK+pCy8j4PGtKvk+c8aV6DfTJdyDiSDA/o2NNg2NtU4PJjcLP6vZTFuWvOzFVR1s+oOYjh3YveyMAVlUswG191BlvcMXCVuG/+Ts07+hW0nhsK323izMNe63zwEx6lGoj7pnwX/rkSlWjkxzGEiPBO+Lj0V5WQhlbtAYGPARFDxnbA4ZzH5T8HW4EZNCReZICntFFmg5DgFDZ5Lms0VFO9kCNMPztKr530lZdYKtUJ7eQbiQJC2qWRREA7us2s1vKbUVDDrBFpM0bAUIgA6VL3ETJv7K/aUxpaBfjSxdTbDiTEwZ1pwTpByBz7UB7cpfRB5UVB7O7ilF3ePeOrSozbK4Jxh1uQ0RqaSc3GKJfC7t2L22xDJov99lN7px8LyWsOT2n7OoSqgRkvLjPClUR+GM32VD/X0gTpNQfxC7iGLEjgsjB84SBTh8r/o8ELJT+NkoxgcqbRlF8pbhZ/GCwYjJkpVH+43elXM1mjN3GIuVw1g4zKjUH7jDWTSGU1wPLZLndVhFzfD0Zncr1ZjKv+JKFmyq7TG5uQnEG4QALrHlLFX+rRfH6uH/uh4Y2ITXIzUcGh/Ibdl1IDUe8HsgM1W2+C8VflxyGIHGSWk6OnVLpEOp1BQ79ObmRkgb0g9SYEWe1zhqJ1EujApcwDyk6QjEvIGiGbNydB/UPZqVo3XIgozt5HAZ8K7kKJnSRAkTktoaxIiS7eQI8c5WTvnJcssvobyaFaZJWtPVoO59UdF0fA5erTqLQsz5rCNnX4e3rRNs6em4FSyDZqyK9nuRJi+jlICwNYZKhUeasT9a3eXcivO7pyc+hHzv+UKMoFH0oOQjNV9xI6QRCM0joVrcCsWWGsnrrpARkefD44cvXz56+JjLCeoIFKve3gjFJHEvlZSnhi9rpVKWeho6T5njHmz1az8b8ZuHJ4+fc7TVhIukDa8cpeeQXBv363cnK1Av/gTm9y5iLhHNWlkCY/cHwph6msRoNaZzxhkl/60wX3Er7mB1efNbucXhFSm6FhNtJ//85OTNhxevTp6+ffz0zcnrt++CiNRtZPstYnRVLZMbHY6i+nSSPPjXr9GvZ78uvybDX4sHZDyxLb3nd6NgtLBeu1pvpf/5w0vO0L4VIyUpOL+NV7s6r+QzXD+75hkJZNaUT9QqBoMzeUXQ2E8fMkYv5oxmHVZ29EPDzvd8o+jIqQWBT8uF/Pp4ltOCideo4mybzSh6hArY33gMsBlqkeguoW6vuuWcFqGikVBb3R2RBrMLAXoadxLw1klZWDWtRNB0AMsMORpCmufJ8n6YBDIkDra1Dh6O+eziwpKnsEolDa0n6Rh9Len87cHfgohsOKilwnmb75NBpIIetaqjw+hYHu2lDJnhEGPhI2W0BHMem/USVyD2V8dqsvLdfG0kST7MB4IDEcERE+fuga9tcdtWOw4TJdkLm+dkSdzv7yRJUim5ud/bHSiAFPq7EJOD138PpBO/77KwkjYhtm6mDqOI5L6XRKpJ79++DPJCREpF34YWNHjwr39uy87dBviiy/hWS1trHUKS/T0MLCxBJDThEN4R5rqOgS9MDiZGGVQSrTxDeoMCdAM5P0zTprF1DTHBtOaY5ImSgskssQTihdCekxSG67jf2+XDCzpcfdiYWTBEE4JTYUBhF5tDrOp02O/1Bj0hvI2TXGoG8m92esIdPkwj2JLs68LGnYcMgDtP0uM0SbUJXTohQSDid6ZJwCdkKi59wJlOmMreNWE8kzm8HB8nGzFJtW8vwmfwIF1Gy+V4GBYmZiibSL2QUTDrUcjxKMxgFBZGJxORAj+6G0h9A2AtJqGs+e5ol2Ts2eRtrFThUovl5qaHsTpryNYALaNjRSs/nue8p86ta5n5zY3qI1hbc77bqvAEfLwG32cNhTYRHg0GTLgYy5bH6ubzcXkxXzDOw29uhmWXlSzlUxP+RkRsLp4pYk9AKDpPK777gzrZTuajAQSX0ZL4vKxrum0dvqKaaqqpj2pJLdz+A9WyNmYCLFTdNBOh0/RL0YDjDEgaEV8iDEFAxuLNLlYqwIHXLDDXtwTn2uJnJqKbzMA/n/q1smwWCVvFIgtNO3TvvKMFW0aW57huRS/KT7SV+pYMuu3e1nmLrN/AW4qLNqajsmIhPCqTgWsME/rPd2+ffXj8+vXfXzz98OrhD0+DiEycVC5VPX2rUqcOv/hpBaOtPbJm5Vhx2vNZyiZldWGiB5Qfcwpvc5DjusfwVZreBYFJOCk/0gJZtcD297hcFCzptXhzFUXsMzkAka3SzqAUVTjuGXbjnJVjSenNTRBohcAG8iWFSUZWG5K6rS23DU9SJR+YLohaegAnQGnlsv92KYfx7O9o9Skfa5+4YiuGPvcKO21ihVKsL6qZwzXxLuXyPGK6b26EPG59AlV5xWpwKR+cMzYfPHjA2ctmQg0pUVOUOUaRpnHr9FiHhicXBgsV5zgw8+n0QnRzE9KEKsvQhpZbWKnZZUgVLeEW2BWxLm4fk1E6/kiLrOHzlmnXyXmxwj65If9IJlNNZijf7pdgMSGnZ9JkR1TF5B3123x6zvyyA98RZhPpxxg3QntNMPgaXTJaR6aUz9ybsmSL4yTj1Wdi3H3Vk6VwxMTFpNeummWlkqWlGoaW51DXmU2MfyCcYzk4PdMPXuwiE6uIycGLKP9P5IOzu17eerPB2FzNo0U1S57An63gQTrPH8zygi7mddCyMb6E5FadBkctjD0l8q3gQbDlMXcXeB6fp0VBZ+3G8y34toIHY1nUNVHWuFut1hs4AUMxfQETns+nJ3SSZDT8PJGuvfyqChpSFpYTznXClmLmQPaiGARVWbJAhX17fNuYiG7Xe25bLBE34gcqW3+VNDGh7tBO/a4mHrcKPe1W4TQIzryuFd5N7uJ/oJ6nRUBOT4MxX2QBCUZpNqUd+Hd7XuUXaXWtoHw243WucLogK/ojD7djkXAaPH8SnEW2dwJN69P/ZrQ+Sz+VVc5oO8Un61N8SIJZbtE7y2u2Pa3KxXw7Z/RiPQLflGHs9sToNu8XpnF91baABIMObxhK3FGJnYAEVuLrMvQ64YA/7ybCI8Ueifd3DneVR4qXKTl9UpBXxRnfcV9MBqc9EvAfwZl0n7EW9qcS+8GXYreG9NertNcR42mffjRkZI/0CFORk7pf5RfzWT7OWff5k4jw9IOWdDVPsK95jbTfUkjuoq/A9lDg32nJepKzGY2WaN69WH/e7ZAgyz+tOUMas6tPgsWsZdauN2FXDu6JHNwd0j843OsfqtH9QY0uYRUM8LOyeq3GGH7rYfYNZFtHqpNL+2/RHfpx/Q7dUx1q+oTXlOYFrb58DZ/H6y9iM51ff+InBr3slJMOP0Lqwe2rVm4BL2TX735515NRHsY7ce+gT35Pyenb4qwxGsq41QSM4eOzS3rk75X8ked86UVdVqVFzUWzsNCHYxRZrnZeT8DVTjqfb4sc26XsgIA8nnyRxx0vruZAfJyQq4lyvBPHu/uHusMeT8jp5eQuXoOMOx5zTr/BE9DDx7LuLJ8IDd5DnjUSBjEPb2NRipLlk7zNImacWs8NifU27BWvh1TJHyoCjMKlpa5qc3Oj4sJUTbNhWHTTLAvBbYzxAllE0UAJsa9W2XJp6po2dSuM4oCk61d2JDwn7ojRWS49ZR/LVJsdZ8vwUUSetBNswv7a5meFY25WaafWXOqrupdl9TEpSNWd0wJiiWzEpFrRQFW6GejIkWx65ulUTbMI8c7H2vLOBC4SwmKm3NNpGrE8vQE3sTKnjGVCx9fjGX1YXxfjF1lYkUKEJwQViGpQT0VzmqXXStJVCPJMG6zDhYHBpCiS3g/sobJzr3mD3ItITdmLgtHqUzoLaXcyW9Tn0pmZiP4HMSztinADGxU1jcN6Wm+nfHWLdgMM/tpw5+hhOR7PaFpp2phDBr2i40XDhkM9/bKHGF12imLwQr0zTosxBSe8KaBQb3fMvMNT4YOsESoCp1ka/XGjFZuboslyyG6ZJPYE0+NcSB8zuNkf/O0WdPKFoozlWHUt1jZfTiGNcHSTjR6pko0NurlJhQm36BwK94QFXhiOI/bKIQaltgXOyQhzFhDhp53o8ZpUSWHeS/L5dqyJRppNsTKRptPsDDZukQfeW1ZgjCreW1YkVpOQ3jYWhCp2As1V8XCFLcNVm11zf759d27ZvPyqmZ5e+MvwMorI27ajzRdBhe/ml7JR71R/PYQSagsqykt/HDAvlb5tRdMJ92ieqsQhQCONEixVQFFRXno0G08g6kZ5qaX8H0Ej3zYO4hWovrkEP25vJ9DyY3Wpbs6iwhMNh4Fx2BR8RpnfG0lSDg0oKBpUYbR0DrNSzezk9IwI4BPl87TULc7kEiXlneaFPK/dHhdt5DOjjXBOHqYd9TzHOPANtNVJPJe98OGYaHP8Kjvg2IqPSCMmnmbTyFgFFyjKHk02esdZCfrbRG/voTCQp4SKhRhF4g325Xk+oyFNWLc+50yfMHe1sMV8fk7KKjxG2Y4jam9px9IcZrmEVfV2EkXhk0lEfrhdc50t6El+oS8SEBOzJh+pZxziBell57eJugyRNTj4tV3Xb6t4L/0ceuUbjFK3okAztEoqUnYzOioXxZhmVmgg2GBLuH0Rvn3kh/O0FjCf6ysm9ofCjcksD2yaVk9kjSG64hFI1WWNrkRyUJydltu0j1i748zMfzlpdnDjpB172F67rlcQME2dEzXLCxkesoWdtgo6t3DtvaAabZ2rumuOnZ4yhyQekQaJhQixvVw6D2hQ/S0nurenlT0SevR9UX7iMhahvmAu7XNLvGt5h+S+lyD3UbfbjWbi/cR4AJATLw2LCDbGghRyu41INVQ5oxWWyby2YSWdrsmdmvK9HqzqB45pWxV93rAPXhHTQHTZjO9KPuvnzc1AfUbuXRt39C3ZPDfdy5BJu7FFwo5Z87Yfnk5GZOY5Yxfeq3NRQL5Kv1szyqItYTIxhNZAqDjZ/ITVvAAkfxEZaZat1ZHNPkxVH+Le8NOYOkgQuSKg8s3NBjOeBJTt5cn1nDru4+FpRoel1RSi6qqYjeOkR+aJQnE8/mZ+PN7aimjITsdnerotS9gLZ9ESZrjVS2Kxp9V0cQEBKKTbkXgonm6j058zy+K00LmjAfiI52JgtBQPaYCTej5pbuKMXsxnIEMvybNb0v+4m23tZVoVFsJxWdTlTCR4PMc9mjSe/4ntSW1UZvv4DmVtPIKnm5uAymT/fdL2HOaZzAJqp58myefg10V/d7QfDIKHAQl+XUwm/VgBV+Oe+Ym+9nXumKb7GNjFQIqBQ1N8R3/vxb0eBjDiUQ8XpzgF1zIyZXr9/j7CRhHxu+h7hnGlfZNpD2WapAgYZ6gOTHHfoji1KB5jInEn2U1GlPV3TKX98f5EA+nBDtQj6QRkTxWhYwzRvoHSgx1A/lpBUO69gmBAflRQakGA82dByO7oIBgEj9Tk6Gsgpj0L2MXAvgZ6/d0dA8SHfQzEGujvjjhFj1U9OxroxYBNA4cYSDEwVsDV+EB/j6lV4tCk9Po7Iw2kBztUA/3d0VEwCJ4oYnY1EFOo8omqkuKUMQLiHgb6OBtFCFC2Xnw4wgCu59CQkx4cHKGUCe/CJ7+ombqLoQlU+4dK2zNQf3fE0T9VDdxTwNX40Pw8Mj9N7pjCrqCAEcUpuxjo42xjDfTiGKfEuEy8j7PtYmDfEDPCiFOcCQH93i4G9nGZQ0wmqrLfxymxRbOVYgGYgqMeAg5N3/R3R5zqZ6rD9zUQ05hqoBcfxRpIDw5Mmf4udOF3CsGBBnrxZBcBsckW034Pp1AEWCl0H6f0cQpGfbSjgfQg7SHgIMOAqae/O+IpzxXVhxroxbCqnitC+xjYN9n6QLVOscocYiDFqA2C/nj/AAEHexpIDw4Nbf1dmMgvFKFHCrgaj83PzPw0uXsxEKKBFANjBOz0TPGJ/h7TPkXAGONC2Xr93iEGUlzGqhJjs+o/OtBAf3fEUX+vmptqoBfDqfG92rsPNdDfhYX/d1VmpIGY7piUXkwPcUofpcARpFN2UcqRKdMf7x9pID3Y7WGgj4FdBKQmpb8LzMpLRehYA714Z4KBIwxkGogpEKqBQ5xthFPGGEhRtl1DQa+PUPfH+30M9DSQHuweYmAfAYc9hBrOtpdqtGC+vPxNNZwj/0E1PNNATOF0UwD0qQZMmf5432TrxUdjk7ILbNsrhZpqoBdPDhGwq7NdZbH+HlMYLJ3pAKfs45Q9nJJiANXSh91LlTnKNJAeHPUQkOJKYZW80v3Gx/GV7jee8bVq3EQBV1nf/NwxP03umJosHOhhYB8Du6b4Hvq+O9ZAr98f4xRqUuJdnLKHa9nr42wUY8PATs/Uv48zpQjXGFeJaunFMJaqTA/T3MNlUqv9mOYM10OtbBSn4N4cWwgOUT00xcDYNA1nmmDKDlGj4yM9wnylpRgY49YAMS9UEqDT/QZp79X84UP6Rs4f6Oo3anh2MbCvgV6cmpT+eH9HA+nBXg8DfQygMrvAufxDVRprID3Y28fAoQZ6fWjsPxQCvgzfKgR9DfRiqOetovoQpyCgD9yrBvq4TIqBMUawj1MoQrBrsvXH+4aC9ABhSw/SfQQcmkr7u7AXvlPt2dFATI+oBnoxYFMpUI9OGeOUHkpBQEz39zHQx4ChoNePDzFqQ0F/fGCA9CA9RMChIae/Cwz4iWrPrgZiup9qoBfvWyljk9KPrWx9lO2gh8tQnG0fAekYAyhbf8cA6cHhPgKAGzr5RbWBk/BetWFPAVfZkfmZmp8jnbsXQ2e+VwQf4pQUp6Q4ZWxwjdF3C3F2gIE9DBwhxMAVa8QUAdB7usyOAfogs2gAI0gnGDVuAMXtpBQDYwRMejhlF/dAH9PWxyn7GMC07RqgvwuH4Y9qkPY1ENODMQaoBnoxKF6UxmAPpfThDFcpsHB+VLoE2NF/UhUdaCCmwOJooK+BXgxk65R9DFgphxrojw8Mgv4usO3/VJUeaiCmIGNrYKyB/i6chD+rMkcaiCkI1T+LGZbp770YulpnOjQp/Z0+SjmkuMwhLmMh2EXZRjsI2y7F2QzQ3wVp4RdFc6qBXgwag1/UXtjDKSMMZDhbHwO7KNtozwD9vknpjw8mCNg3qNODfYOtvwtcUioJBU45VfWkCriiPfMzNj/7KHd6gIE9DIwwcGSK7+jvvbgXY2AHlRhhmmDh6hRcywhh6/cPEDZM8S76nmFc6Y7JtIcyTUYIgImo6sAU9y2KU4viDBOJO8lusqm0P95HFPT3zAClB3CQppJOPkdTqgjNMCT6lqpSgK9UEBCxUBAMyCcFjSwIcF6rmcLpHamZ0tdATKH1GtjDwIEGejFsKxowZXr9PQP0d4GJH6t6djTQiwGbBo4wMMJApoArakrE1CoBW9RY7QpjDaQHIJYKoB/DtjZWlHFiMkXZrgZiCvVnqv4JTskQEMcY2MHZJggBytaLYSvMVEftY+BAA+kBnLyqzARQa2XjvoH6uyD8UNWIPQVcwcknfx6Zn6nOHVMQ5RUASgudsoeBHZwt00AvjnFKjMvEBzjbHgYODDEjjHiEMyGg39vDwAEuc4TJRFX2+zgltmi2UiwAV7qLse1h2jKDrb8LHM5E9f6+BmIaTzTQi2HDn6ihHWugvwsC41QhONBAL57sIQCaMJWo4RZJp0wQYKVQjA2U/joFoe4DFzGVtKUGQZzB0aZSDkw9/V3g8s4V1Yca6MWg7j5XhO5gwJTp9YFqnWKVOcLACAFH+7geg60/3j9EwAHK1t/fQ2WOAPik2sAL5aoNRwq4AsZQ/szMT6pz9+L+EQZGGEAlJvp7TPsYGOPicGDnanYfYWCEy1i1WKgzVGb/EGUDuTVXzeWof1PNTTXQi+E4UQBwwr+pRWDK9HdBlPioEIw0EFOo56OaW0c4ZQelwEGlU/ZQypEp0x/vm3rSg90YAzsY2ENAalL6uyCPzBShYw30YtDNKQC4OA1QDcQUCNXAEc42xikZBkYoG6wVXWkfAUeo0v6+KdMf78caSA92jxBwaKUcIGwwkWZ6gDhxF6rdmQZiCkegAqBLNbCjgV7/IEbAvinT34U9r1CoqQZ68eQIAXCGAnAFd2eFqmUPZzrEKQc4ZR+njDCAazlC9fdBGtEITLb04ChGQIopAEmp0N3G0ZWqbRMFXIEwIn/umJ+7OndMsx0MxBg4wMCeKb6HvsMYlbIh/QynTExKvItT9nAtezs42wRjw8BObOrfx5lGCNcYV4lq6cVZH5XpYZp7uExqtR/TnOF6qJVtglNwb44tBEeoHjrCQGaadoi+T3D798yYpQe7Iwzg1hzs4dYAMWpbhYOsVDy26OlSzR8OzeX8Ae5+roZnDwMHGujFKUrJQDScS9zQ8xrYwYAp098FCe53VWmsgV4f2ve7KnOAgSMN9HdhGCqFoK+BXgz1VIrqI5yCgH4cY2AHlxlhIMMIDnDKBCHYRdn6BwZIDxC29CA9QMChqbS/C8Jrrdqzo4ArGJ1a1T/SQEyBNdApGU6JUQoCYgr3nRrYwcCRKdOPjzBqREF/xwDpQXqEgMM9hO3IENrfhXXBVNN2NRBTOEAUAFeQTFG9h7NlJqUfj3C2HZQNtn9dZoKzYdQpxgZilwD6Y1BvMtWeAwQAw8SUyAJi+0I1aE8BV3CWyJ+p+TnSuXvxvs7CCT7CKSOcYpXJDK4x+p5ZwCEG9jGQIsTAU2vEEwRA7+kypoW9fryHAYwA7LA0atwAittJJxjIEDCJccoe7oEdTNsOTjnAAKbt0FTa3wVsn9Qg7WsgprA8NTDRQK8PRjZK27BnpYxRCiypT0oPAXqPS1XRgQZiCoyPBnY00IuBbJ1ilcEpcPOtU4400B8fGGz9XRjUK0XBoQZiCg3SQKaB/i6I19eqzJEGYgrMwrWYbpn+3ouh33UmU6LX39lBKYcTU3yCS+DiR1aFe6gWMOBTiHctBAbo78L8+kORn2qgFx8YIKbAQ+mUMQYozraDgT2UDazzJNDvo5Q+8OJ/qJ3DoE4P9g223g4opfmPo1h9OVRf9tSXI/XlQH1J1Zcj+SVtfIEpCV8m6guVX1KFGXSd1hcYHviiMSs8I0Uh7JDwReNRmEeKwlThGSk849T9AtpkO4+uS9E8VnWNVV3jkftl1GvkUT021pj76stOsDR2tL9Y1q4mivHpv35d9Hq93jb/c/D07MHU97b8p8kpPbu5odgxwz8m2ng6SK/MfwFCfuXHF8b7f/shZefdKi2y8iKMbnqRCeUV70fSZ/5X7bbF4ilnTWd0zGiWnJ4pY2MZskgEJnxTlXNasesQmSCTAKI5BuTzlDKP6xwb85LQYnFBK/BSvtEj47KY5NOFgsG7LI7cxks137KqFJrpFy+6BvWcirAIcs7TihbqbdIHYZT+Br6ZRB2VRcDd8Xk+yyqq4tmTypPUGge+Y6hbqgDwx7q8JrxIkqRSkY8VVvVM5ENN2WP57Z0s8Y6l8PBL5SUb6uG21SpVDF76W725KLz9KV6cqac2Zg443eq2Fz3UArtxPnJmVGK7+zc3Gx1gHsE7PXu8aqRWNlhnCguH+ghmhXy8UpA6rG5vTwRz0Rm1jfjPDVl8tyGDh0eNh1bWOrXytxLhjDn1xgpvzN+EuW7pvXQ3XzR8ySySfS06f0Wt91ObrmYZRuTvt/nC+FBMRXeqF3cfckYv4DGrAEVNNHthf75Iq480e1Fk9CrZjq2dKi+LH8qMzsBhxleTO+y3UPUt+y3kuX2zXaM2q2W31GrlvZfa1VCuU7vdryLI8L0QIUeR0Yu7tP+0MQXO7pMajvAWclDOe6m5KKFhJ6VYC7fUrpZM9zzPqNqMpKcLMT/l4ah8RFhjLdPuqceuAKciYl3CLxYzls9nVBFtEtKrd5jYb/7iBszSmuEKVzfAIuO0lbLteI356ATgF9ub/4H7Md4YqR2WHsez5N0354jgq4rVYToXPIQ9upbxmj8AWCcIeCTDqYqqWopH1j4tl+csZYwWFuIoGtgVyTjxBH8E567yzStCq3xhOLt/jclzTrIGBwb87IY5cjc3N6C0O2ctVwLNKXqswuQBx6AKqWfF7tYoQGAF3O5zFqua+vizeB99C2fJeQzTptBLhiqm3vU3m3ULeY84hwluUqLmGnUWb31eXqIWOOMyyQsYvebcJoKXVJ4BGiMwLi844/JTzs6HHkaj8GdVQfAJjZYDB+MoLzJ4oe7Bt8EQ4wkh1MrZJ/qK1rxVCmfhQxYlnOMZeDkvKMbT4VGuqYB1Z+mIzvQPCI9m19ms7SXPqTwAy42ed6+P1YS39s5QpFnLSCRyYajNo3mSaPdiOAnkQeZdqibNw3arydLGfutpDLnDyG6wh7225SO+Q/LjmYsUt61C4TmgpuwZpt4N0s07+dE1dL83dG8CSgvwyj1OZxT55hbV211jD5mZLb9MQjkbvKjAaQerwh5RwQHExGvQyuvyrTaIz6d6usFWU3f51TStxufPiiEdtDYPewNvlpQb5wcZWO2d/CyjOrYMCo6homRokpMxmSenZ+BkSr1TP09mYaoPEvBDHEUkS87F8/PoeCPrZmVBj80ngW+SZGJhHpebm+FES9ITVyi9uZkYqfrmpgopSX09NBHoBpNoc3Mupv4kWmIHWCpkxnI5yYt0Nrv+zFvCzyRBI8QxOe+KmRBtbubiUfx5pPODoyz5nF8Ezlgu80k4V4/re6Jt02QRzsW7+nA7jkgcnfbO+MhPtb6GZ/uUpLftIHzbUoWW0XHqXeGfomU4Ttw0SykwJnU4j/jBlkpuBo3hOJmFwinApCovLH5BBPOOIPLHWA/pXAyp+RTl4Vx0P/I4xlo6fL65KTGAh6qx6fBCdPjY6nAmO5ypDhcqijV3jWaO5oZnd6kYShXXwNqA9UlvL9zbdzcfg/ptb2ifIS0Ktw2scBu0816Lgu+49tmiWmgL6nY5nvaKXjF/yZrR+QkIRmEcNQu+qeinvFzUtxbe9pVuHIRNan0jpDzHuY7YeTnV8a+rJ2LDc5nRnh5Z37C38KF4SIfb8WAVVdozDxZppIO7ZtPcjJub7NvteMgGdNhyakFh/zyRAQT4PNmOl42FYPiaps55A/xhKCeAlG9W2+DeULcr6JpYFPSUnWlXJUXCwOMegyykSigpkx7JE6VgPi6/yY+3tkoUpqGywoxUSXVanJZnWi1fuQM7d6aK8X4ITPJXxVSEOhDc2dD9MlC7hcXaeRhTUZ5UDlrBYg7dLwMqObLP0EkDRoBzGDzix8SwMJcU0SAIiDieKqJGaWAGjJyzi9mLbPCPSegKHxfp3BLG/f6Zjj3bTINJs3yzKpEgpF7eXHLNp97Us4FMjo6rzU22If3RWdcW1BHUi7Ok8ojD9mbZvr2666BF8wlz1qnarMxo6QpGltzUxq+1stbU6NBdff+xr9CqU75SPgW9NVWRdoVk9O0RPsTLZIaTSJ6U+rzOxXltPimfUblkwRb23UYbFQvMT7Ud7/nmpqwQjveycbyXq4/3VToHm6a6rFpitUixeVvuXs1hx9POcwL5zvc1ZyC6LxIzYdi8XKOfaHV9293aSmbjTsRo/jEaeC52vnyxOZcabh87EoffDeJt8pY56791GZcPU8oU4yJOVF+PajYLH72rWIDteNgbNIpsxc1v3yQKtx9Ps0SjCYZDsojvraTQv0+smFSGL7i5Cdt4LLc3Q6WeMvcDGpHWOhkGr6FzUtpM36lNKlImv6udtanczJWe0pJTFnyLi0idLPTOVoudzXxSntxqqSwagwdXIQTx2shpKlLOooH8xXmZMT/wx9FwPJCOlEUEyhwk2nF0PB9KkTKNBjnoS8fkND1bR76sNzclmeCacGH2w0rsh4vV8qUcxdzpXant9Z1ZpFrVt2VyekbyBILpSK1vdHNzenZcYoGxJHWYR0K3wM8JaSqQNvUC/ITceMQ3csnTQdSHvFjQ4FhEm/0suCJG1N4jO5mI3QPidhLBQS22tgx/tDG25PyZjGf0HW+JxTEdy3MsCUV87NNqOPYxdoNxs0POEs4WEdH4MBctnsnuYZGj6EeLShCf5MTsqcrFrzx+Et4auoyOc5NjRhrdPBORPhti+dwWy6mRxc+TuV4B52IFmE9RGp6vLYufb25KDHBYzxuH9Xz1Ya08vsqb5p8nTfb080k6GhyRpwWj1SDeIU/r8aB/QN7N0zEd7PTJw6oqL9/PBzuH4ueT8rIY7PbIo3T8sYZMhzqyJudHT9LRWRKcpKOAcBDwniUB/JWf6jH/UI8FCDWdJQH8FZ9knWdJIH+hz7x+lcB/iyRNzVkS6N+BaPX3d3NqqHz2F/kFeGV9VqUX3rjql3mRlZf+/A3ht6bsJL+g5aIlErpEZrLJSHbQgn/erQXjdDZezFJG3QszYod/4JP+Oc2n5+xvtAs6i5dCIGTdelyVs9lJOf+2gqCqGk4q5bMbbL4u0quwR1B69KCykZFc5syL0E6Az2Oac5ZzS6W9odXjcrYVRxGZ4SrybSvDdhyRhUE8E8gms7KswjLih5DdPlPXItr2JHEkC1JoFX6d5PWr9FVYR8PeoCYLCS6i4XY8WJBcwjnAOVlsJwXJt5KCfGbl/E2aZXkxHdREdIuoaFARiCA5WOB2LSJCi2zQ2km5K3DqwX2SX9CituMHao+7YogKvks+Khfgl1/Eh39LxyzkJ3ilN71Tdja0oLZSg8+XecbOB2UX/pJz0a6yK34QVs4HvSUet9gaF5nvQS5/RJGWz02LB5R8yunlT1ZN/MtzpzYgWGTLZTY0rANVCUGzZjBTYQzpdFVQWOUtWBlLFRmtaKWtb/4oC6q883/4lFdskc7ewUirkHoy8MwHsaoTGT3iQ1aOwX9rkstwEpa9zrysc/C4HKQLVsqQsqPFZEKrhxcQQHZXfLOq1BLhYp5BPAZ62fmeKe/kkKP56aR8WmTW93LB6jyjj2f5+KOV8CGjNavK66/ga6n6AKbyYv6yLOfGCjKvBU00Oyl/UPdLqoCp+Fle4ZQsr+dlTUVR5bHXCWuDMz6RvfiW1vkfdGWBqpxn5SWXcouU5Z/o0xnlJdujlv5QLmoKRfCGH7x49eb9SQDCmnAF3GXp9FV6wY9ljgS8BEuNZgi2iHwbqMp5Ok0FTc5x4Auv6KqL5E1fYrdFMjayJbKhgnjRg/ouUM22zU1Kw/eK41RfScDKxfgcxjEgn8fpnC0qaXfhyXyhOsbJK512v9El5GyJIuRA3yObUkX0azTxQAXU7KjH52kxpbVzvw+LR4vJq6aeqAgOQ4FK7bG+UXkiGtDUlq+cfabTfZPZpMrekbyg+9W4qJeO9OdzWmQnpZLn1E4kvVuDBWTonR6vyow6i6DR1ocTxnfFgtGC3ToXL89pIfO+pWl2HUZddk6LEJWhiN6Qdj8I6ImsHpaFHAq7D0OwdRXbl8r9Ru6FYWNCVHRSURznwiIWxRZ6U5UXeW1PPio27261KOS8e1hMF7O0stvxYSVrZ2cVdMvLLdEnMIsbhIsN8EXBSvfOwzYxyJ1LFBDgQvZN7+aGfYuzyCsRHawOxsnDHoTNQ2PYG7DIBNHin+SG8pZO7L2SSE5PnOFF1xzFDwrMR0XbsVbGWnVFFeIe2d+sQtuFnxVjpEQRSfLEvf4ci5nYRrPRs8pb3h5hkQwh3aKR3GLdMbA6gpQl6UXHmPB8FanL5bJtrE/SaUvIhlu6na0Y0OiY4j61CAsZ5h+33Hs9/zJr7nbjRcX3EZ3BIeaxnexsQhE/XOY6dr2LTBnX6e0szTKIju2gIUEx3RaH4DbHZ6zX7W3wlqKjkrHyolnaqVXk/oI6mwVVjdq67y4tbSN3vcZ6ab61pevX2dJLLQeWmG0P4SvNmpu7c0R1ISx0t5yn45xdJ0EcuPcCDZah1R6/K4Ob1qHi2fQFjq6uNQvmhrv0Imeu3YLFca08OP3crdPPM/gerrMvBCI9INYxJE9FcchO8krWB+x28wxtckSrrWrbefe5NDB4x9nIxDJSVUlc0pAJIY75oINlCQaaZ4Xby5sbk8tO2dz0ZFfHoDHztCSTCEtatCt3IlmRkrx07zV4GoamtN7TGhva5ia7fa43BgFxDi0zKJ+E/2TdtK5pxV6V7EUhuZVfyoLziBu+wxabICpex2ZZRL1iWktGWB6TwIjp0RZsNCecSF5KXdFLozbEMSK1kv/EIiVP8gnLjroqrAi9bQ1QSyy+uelF8MQNtC6tPIHYW4RSICm7WDWzFcyvAkJvZSsECh3wNwngJyf95zDYKrtG98MxRgEpuzAbYSrba+XmpuzSIrNTnhbZMKR3HzdZDQGUMIiidSLvZ6F2UplokQ0gI2dRiUtXorPZKxhKkA2xAPEa29xkECzXmxRSZz3GvglGQD5eybuvNtp1dzyPqZOzg8l9fvU8MzzWlntwIFbx28THYAuNzuopOViHl42sytQuh9ojz6dWNUvP7azVGsRmMENQcug4vbesYVfswKIKoWQtznedXvEeaLZcuepYRpLqOrol/3EdCDExIEEF2Z0zeY0ToWHuYq0M3ICNNjWHZLXMLfBKlUgPjwCXT0KndIOkNpbfFWKF0lJZ7yldpnUeqY/H2IhPcmttiuoiUTqorvrRWJ03NzrPqMyuTYI2yOc785YU6ufplP78ejKpKdti8jzYom0EyAzfFlutdOD1OQQmYRBIhtrpS1sj0pyfuorfF7S6FhehZRVaM1boAyiKWiYjlqkMnVqW6wRbVsmtoJPlWacoWWfCW9pJi+uOUBd1qGhLwA9Skd+nXPJzMG0T/Avb54wmWXuitI4hqSBS24RtF/Dn2Ct1MBClWTnfLmC6hGoQW8VYNXsG2yuOh0gwF94qRQWWvt/NwulNqhU44OYjYeLvinwXefFTI6sznq6Sr50t1RYwlipKLrd1uEWKCLRnQ9AtptslWHEG0bAIo8FaWjt0c+p5mRjyubvHGYe7shlLfrRO4fJjQkMk90r7KUlqHUSkWOtSSRgwmKNozKVrWqsLJZaOhNmPukMaZ/r+SIbXS0oBU304+i+U4GlQOpqZyKx8n3+WVzUz0e7dRYsn46xMrYjeEMD9tXzbr1FYxno6+Dd8eF2cpCP9bf27LMeaBH2XxmomoKp8LcW/vy4eZuaMA6uWZ2X1IkO51bs8jTHNspN06lRg9Vlev57TwjRitqggJqd1SzYpx4u6+XkMwnXzezmnhSc3797mZ0GTLztNPaSoIKPWRxRL9EtvCJXdj+4JoWbMa4Hx7zJUvBpWevmmrJjtkUBYxLkhcdUUfJEl/5goRhabCL/Ikp6+KoFFJ56ZBTDEgdE31DXN/k6vkQsE/+XlR3r9hud2PpeFRxmy1Ikn5WJ8bnNlSzQSLc8GZ67Zd8vLNvQOchkdo+epTL9mvKDVlH43K0fp7DG8leZ71PqeG9AD0FveoKOcS1LjjPLFMITblCyIZD/+ExX6z87FomadEe2kHVW0G6hHFihjcj8uEpSlZVuzNjbc6acf/qjl/u/2F6EXjz097pUMaOktdNiTs9WaTriziO6FPBUC+y6EqTdZd/MZ4LtlF3NQyIt/l/sAbbxLa792dl52m3F0377rG2rFvorNUKtuXFUklICzRktwF2mxSGfi+HHFeHl/+2NOL71NlJV7GTWXpmdVefFKvpzxdkX7pfi6F9o2Tt39T1xTi3wS/jw5pd3L83x8fhbVlzmYSAo4+jxOa9r5eWJMAQd4PPXXkEbHo4qmH4+tAu/nzezv583MwvgRZ4UvzYzCahJnhC/NjCfpyMp2ko482OrxwDACoZjLt5uWOFiMYSauUH8NI+VD6iO93twUD3I+0mtnaugjUgalhyyeFwDegfVb0YjzUF21HAd5MV8w0BgoaxqoQKMGt11u+zkDDitNFATmmRcd8oSUD+j2ZcVlyUYG9LubF+PZIqM18POwt23nYy5vaAN8YOi0nhAgw5qoQ2OomblQPv1k5XQ6oy0mQCILmnvC6MX6/pi3TX73da0p11zxsHkM8QwaIAJ92ExtDWxql5YTAvocPA7oVY44b/2IH/fTh7w+uZ7T9JymSkvFFCxmFecBI5eZ9d63meobhGopR22b7VuyIEtoLV5NZWucmi6rnFHBojauFm/DLDr1J41Bv9H4MM6E7FVWj89pc2wrOs1rRqvXPg7UYU5pW9EGf4rKqjTasEp+Itl611GbLKu5frpeS8QC+HNzk39rYFCEyBUpECpAj4vruEZd+ZqTVK9wNDtlLiEL3txsOEgdz1P6qlFJhj3SoMLz0jm0JfDIkQQtNT7iVH07UEYZHTPJnzRmMPRvywgoBz+oQ9zWxO3L20ykMHJFVvsaojFLvNOkITJt0Jsb6g61AUNLhufng+ISxcwyLn3k7NLg7Y6QKPJo4e4jGo1f5aDOTE+POdyiks3VJZ54B9KyL5GwqXRpTPjm3MRrzHF7wudQY2KIufaCH8bO9Zecc2t4W3KIQuPgOxechjY0FLJ3vGPms6ciyk0SqXwXWYW11oeFtVC1LzB+FA1wmvQExOk4Dpl+siU2iWiIgNBds8oPxLzKL3Leo0M3xyAMKTyFEjol9QLqLHEzEhpFeVGztBjTcqI0lkPmWCrg1sq+r2DaR13xyAgrLaIBsxxfhFXIGivknLMZjv9PLJ81jl3FMKgNC3WH2nX0Q8e1pNjz8vIh9G9TUMwnYUOkl9rnjfgYGdmhdJu5tHw1iWFUVJop4L5nvvCaMssHsjZ+ocfZ3JR0Yh2pOmBsCfcLsOt+lXraOzrUOy8vX4nd41m5sC/NRQ/asqOnR6T/COkHmurDxWL8LBJvbrRLtCZ3aOlnrGK6pWZSNKcrR8f3Qb7/embtmq3xkufRH7k9v9q9lFtesVOC/Wnyy0Mfu9zcZtyDSr4Fb2QkFgvwJdyKy6IVcGA8s08U80BfSU8CDW210+USmdpt8eWKRBBErnpdnQ3EqqipHpEEPpotPAOxBj3iOFpBkr4HsCmy+FKHkWmyT4b+uEE+oxfPy0/OPGowR/YwqgPLwmVxix5L36wr9TWGUPhm8ZhfZEWsL5fSAvz4Nb61W/03HEu3Of+kp72zY/sUTWzQcbEG34hzQCdsuPHdJGSNk9tl7Y0aL9I+5r7tybY5MrPFZ1heYkJnRT6aNNesfzddd8G3CjmiyujLdoGWYbH0h6vMbpR7HnUzVovXQ/jWVL6upnCHk/SO2TdpNQVzAH3esK2tiJ6ys0SnnLIzdaA3HsAn9JQap7PHr8IiGtLuvJyH0UBcJB4r00XrPOvcJ1VCzab8Q/QRtLn5KqSn8Vk0/EfI53I0+JSGUfi8lk/Q1Zv1KFqG8UaSVDc3xbD6tjf8BTzYDl7WYREN3teiMGHRchnafR2R5uss8kft81G1oahatr7fEk4FKFpt1Fla9oMb6QK35Wrhs+uxSfqFcPxD0fYtOy8KWj0/+eGlz3HTcqn18M7qlQ/ACEWLlq5esbSxJ4YM7E5oSJszm1Dc3ZTaw1lbRVqvXWqWMirq+2oZocd2Rev4UGt3kE6klD8oo85hxrkV9Sl1mjaWOe+mPPvJrx9DNuPS4QRVxvRGBg4C4eZVPOfJa/gb8q2uh1aEzcgXHpFOeEMDd7Ha6RXnNbSFRPcyrYoweJSDLVCnBGkjDLa+f/f6VbcGp1/5hNe8FUSdy5yddzSeTl6DiVQ6m5WXNOsGEdmIjdmI1aKh25AhbffzUoBFiXoRYhP6g0Qobbc6hZCNO/V5uZhlcJEKNQliBkXjjG+oHlcMjjoZnOHk4uLnZo9LhzAJ880r8TqtilhTWVKhB1xlAgN2XN7cbJT8XLM8mTWKsnYJPRqgspubyqEIwyI0WBYUp9ghGme316unSgpZU7RcHtujvTJuhRzeoumfunHZ2K7AUH7i1AWDYl3MbUzLa1vys28/7xSWWYTyiraMSEiTfq9HtI0vGBYnP04igo20NJZZPmEh+PyZwLM5jgKfIG0V6mvbiHx3e+7fyrwIgyBqOXz0RC6cqSjdDvMZxttRKG1zWPjYY75n+xSUA605YRFksQ1KWp5vSC2Wf0gdZ7xVMgubkn9EyqTS/mJK4S/GfBL4crJISukNTi1h41w7Txb6yeNwodwm8TzKi87A4fZsX4uyCHHQkkJ73YErQwkulPsa6b+GHzrKfw2z/dfwxV4q/zUsqYz/Gib811SW/xpl1UqV/xre9NoX3uA2QwVn5YZK/pLvv4uoYZ8lxDjkkV9nfjQJC85bDfm/A3xn1SjNs6155YO1xS06WbXJNZQHxnbKGtGGr931zcub+oHbZTfXiNxea9KcvIUCR43756o/Sact7/NO0pFHT20ZWSBDxWFrM+QEMrcWK1rsubVXtxFaeTXEdQP57aWs6zIJ+FsLtgdt7W3ehK1o7vqtdVtmKZahZfieb02LBv9by3k69t3JtrRO6Z5aK/bXok1IPFqtQvnfq3nD4mjo9ovx8dx4jwNd0VTYYe/OjTLqfVREVrekvSHv57dNf6dR2/fWKux6ekXLbh8Xi8C2uAyNuQlOIalXy9/cYVunN+8lcLywnu7YPxLa9Kb5nqdJBbpWcVRK9uWnc+HpENfwbz0wyI3ZwxqXMFiBtNpej7WaepSjmlafaPWlVnxNu9fmpIYYleflLFOPtdCHmxuKQTEVi5LBrccJvZJTCH/hRTBMdJPUBYMp537lZd1v2NbclDQwL2Mgy/jeZEcfeH4Eomvph7OZKYG/8CIYlk8bqqltz1zanasfMTDbPTUwb7wOot7MH1fdulxUY1onBam05V+W9EjVPU8/CSGzTnrHyjeZ0rYJnk3EPhKCdBlp7+V50jvOvymP860t9XTij7AixWl+RoRjyuh4trkJPg7CWWQ8lCvXhyEjNCIMGzSWLJ9c81234TiNlHI+CZJOi7OEkZIvZHW3GSLIvIDQzdvaipaeyh7L3mjbvrgclxdw+klJEOFUfloETSAt6Liempahcowiu31ri9gfkiQpwYkk/GVCuqh4zxgjTRCvsc0mW4aPIpK3vWsx7gfvJ1DruCxYVcrHsxKQYUP4WN+L9fGndJbfspW1kZFn90dGXnwpIbLk/ZEyp6Al+wJSZMn7I0XpJL+AFq39vTdiaPGltMiS90gKF4dvseT3UwIF73GuVDnfqb5kHaui9zlbKnb9RVOlYtf3RwYTd7pfQIgseX+k1Cxliy+ZJ6Lg/RGyKL68V3TZ++4XeXHzxd0jy9/rWbSgX04VLn6PSzxd8T5svVoaEZ5svsd2LCF9nBPcNCUMyYYCjsadx3law9szr0Nl+eTLj0+VVD6WEdIpZe1IV4yFKgfZ1WBwBnvWylBbnSp8IlHsCl/fI0sO22Fp/UPJrHdxZXXxJK/omOWf2rfsPzNz2D3PHLYM82l0rHtpMcW3GRCbiN7c4NtCoSOeJg/+FQ6T7ueY9Pd2l19FEtjfXf5HdLq98f/76v9sfv23rQe97aNk+HD7l399+M90+4/PN8v//9lW+Gv3lhzR3/7j9OH2L+n2H73to7PQ/N4++9wj+/ESpUZDjm/93NHfvnpA0ts5bHjB7zNvxZe/+SRcTPVt780NdJ8Vy0lc8M3TqqbPZmXKQhMqSKwb4dgaXMx/Q4efL/JiAP9Qko7ZIp2p2ELLpZjlS4gl6Q3u8ddR9i2nLL0awD+rKKvo7wtwg+Mhj5Mgqxh+Vhn5NFTLV5c+qRY+D/DS5RGgGPIyAwsNx0Av0twbDxNXDkXraZfRmjlfPwMChe0iL4Rbx7v1tqebZZKKIyXX0qCnvSPIsZffdbu0j27R5RIsnMmwHpFrUiLH+gsomaeM0apIfFa1wzAQdgBBkvDdq5zwb1USBCT4l3w6dp5WD1nYizY3w2orCf4VRKTaShgJvrIyMG1dpHJ+FUSkAH3GWzp9ejUPqygahBW4F1Ehx7icj25bqRo02jZoTE013TNiwjA1VWRzTRe9kR8q2UfCxIYtl8toQLu8EJgApKysjuU1P+82K8FrUC+Xx7i8mFtPTVQ8aS/t0lRtPNW2170kUX0nmuCp63y6Io63115aOO4A43dE5MP6uhj/pZRau7ZSX4lbYFIlveOqaTJWbW1FxWmFTcYqZTIWKHxmghanhTFkgwvVQtixRSSG4MjKokxeWIK6B36RHkof/lYP2JCGhTQn+s7r/8Q1P1tG0QB8pnjtDOhlp5zKkOrLLx4xyDGfRpqw86kYxWWIeIKxyxNsJHSpU+dTo1t7zFEP/xHSaADX5htXcLnfcJ309GoOqvLOJzXtO6zs2N5sOmXVeQ2abM6tdAPzgsDUfT7F71xX+RsWZLNhHn5eEmAZ6ZJ8XuIJl0iOC8LKsMiafgy4nsy4pXk1hcX9cDymdV1WQUQmK5zRtEY2QB5llKeSFT4x/C4xfM71Vz2qNG7VasoMY+nQ43pBHZ/T8UcuXrpSwe1PKf/ES8o/8ZDyy5ppFGJUOSOamlF/DHsbmEyDFcIPZUaDiHxa6YdIKvGP154CH8amGl6D8kx096lh4xOOhQRT761I31G6BIRV8n0aRkP+D5e83te0ejilBRORPDcepEVW8Y0r/DXbih6Ic7Kyn9BEUfTvmalS7y2Fl2EQDP5XTVmP2+FivrA1AvKRlDvO+jWCOy02nHmkrNm1yU6jZoRCuDltPoMwk7LXXthyLko9ZWP/mvESaJ1q11PXjomfRHToOTBNasii5QAdfhd/AgnfFUb/dx8a97oULaPrMOBsmjicsQgbucag/wNWrDUtP0xhhTgM06LIL+aiOM2CCObO5QpFl7TbXE/PZbx2fpBB/IS9W7dIL5Ttm5CEFLujPn6o0kstuQgvYPANmH8n4e7aNM0ctuq4Pgg7tD+vSUstgv9kfUKnRh6365jEBEllb4K1q2c9ppkbmNwpJ8xDTylhZ41ldVF+suerlpASF4sScY7Zt0nveHubRdpoXWc6ZWen8VmSJFqCA0HFRVXPwT82I24YDM8b9obXe4OmYfZdRJ8ZONhNL4SHwrAgNNrcLE7jMzHD+a/uJK/o+wJYVS3Xe95VaCwtmmx62jszmmyA1MoQ3uilDlp+5FniM7FaeDr/IXnHq1s8VN5hj/8gdrLqWjuqzIvfwIOnclfZ3Cm/4BBod+ElW53YlUNc0MupNsLlff8qvdAhlTTZYDBiYYIMd3F+pVHJx6Ke8ivPMHjdk1BlW4ZssP+kTITQ3+V8a6yASaHfKXvGkmoFI2yzqjOM20L3VbReDM2+uMTPUP7HnZgWs6hmXGO+FBAvDn5OyurisZh1r8xXnkE50Pbn+AAnMf8gDmIVA2IV6lDn8GJ26bdrsBthcwFf/1p04L8Xk851ueiIA60zKtl5J+3wCjtpkXXSjlNjJ2WsykcLRjuc7y0XVadKs7zsjBaMlQXpsHOaVx1h7qTqAIeSFykbn3c7T68GnW/Ae1iH05wEUDxw60mCSVlmAVAif38r0H2tZOl300S24pss/9Q55RhgJz5Lgotr+KXKqDw6i6hiTqu6LFAmnk/Q1iQnr2rGf2KcD7L8kwTVbwG9kH0Db9IH6isMoSStk8BoPFMUhZ81WkHWwE3vaBJMkiQxjDrLSJRfRsdfk6ema3hDnF6QD9TEqbWqE05DmTU6U/lgLuphubVPoPavDUd6MrU0aTXnnFJ2Tk7pWWQkoRcyF725eT0NGQkepwV4Ps+LrCM3fHj5F0QuN6lKvCrFHOwoRoCPKIyqi0DLUmWVpFOlcg5P0XdRifgNrh5tFg8VA2aVl7VzEOZ8OGsQbu2iamt2ODanhHseWCwO7X6QFl7y2QkxX+RxsNFD357kFbvmnwLxMgZee8on/q+Lzc2PYkxA10uYS1rzcHL0yKtaGxEIwvMpp5cnJcy391CtUi03q2vvCeWjAR91uo3qoOGtHM0WldtGt4d0q0lQL0YXORNRRHGBi7T6+LDWniE0vS6F7mHGyxqqVVKj65pNdRGJJ4Gu+NTkeqHXTI06q2rpikTP4z/VCUJxDW/O8ixn1+LxsV9y+6+lyewuH9XuYs99M5oAisctlKkVaa0m8ple5KCxnZ2UP+b0UhA12Iih8Z6ZbJePPIsxNhS+lhSK5/ry6E7gTvRc2eHHQzDZGHS+DrZkiniC2dn+thNEW8HXwUB8P+2dDYMCjg2dF5KDRVHP6Tif5DSTR7463ANiWAW2FXSCrQL14BvPJc4Q7Z0U7oKup5E0ptEFH64uKHZPUfpCl+a98GqanE6m5H+BfgspoBqe7/6fgktwfqP7mQkfRPSHH9I5XMr8kM6VMJw9LhfwHq93D7clyl36U/rF/t49btzNFfOGumL2xJVBaDxu3Qnn2jsVHdP8E806HhcLX+j2fd2VIrzmUyum0JQy4VrjRRbS6FheMTWiKN9lCunnx0VGrwKyHUcN7xTO9a7QMG+xQcg2NwPhggIZm8D9fSCGMYhISLeCQSfYYiZk7V4vipagnTy+B533n1EENOeuYccShvpbnHRFRIxu4H/e9oClYU0uNK/pVS50VvvWVoRsfBxkaFo2u5sUDV8BbtRjs9kIo4AoWs93QMNzAF6LDdRTysI8IsYCKVcP/Xkvq4f+dMVD/wI/9C98D/2Z3GaYeujvWBb5Oq3NrYnHHIWC4peFwSCITntny5Da/h5Ra8/TOmTSm6fTCcIoA06L/3dU/A8/KpQtFsM+cOTRQVwvPuaZY4ubicI9YpbRMUtccfZDTfUj3LDSEd2xEWD07XYcLYVD/lsQgBMid5oqcci1Yv/zu7vogdMz3lkFXyWvLws9d/Rp+FrFvorUvlUmRddJJfINp7J6Q085S3izzLebheccmWkDYOl4RIYu4HXxesp2/CHCHWmCNjfDVfUQXU90rE63ilC+d/1feYjpubD6FGvbOmu+R8Lj2v/B51z3wyflZvl//XEn+2JgbgvPyJO/6vkKW++S75yOP76Ba82T6zk1cSbQw5ZummVGxy0v4Vz0bZd4FiZ0hWKwi8u9RgVr3OJLLfHql112ZVPKGjX91S9zTqbmikj5RYUev5+613uEhOsdYsDuoD/1zO2O1hxvZL980FnvaTTWtO54qOq3869DBGvcSJo15DCOy3A2jcjbdrcPaJtpen1wF/UybGGVjbfh5C6MaTF9PEvr+v1tz0k3lElg5jz5Q1/Mw9J7eScpSTu5B8L+ArLe3PJQey261JPt+yTsyapH22tRBc+375OkH1d5YliLJNgh7pOkF6vdQ6xFlHQUca+zarWriPUmlcCxhli3DCNkifgjelzx21Q4WzU780A/i7KlORYN+T4eDdjNjX2R8AO+IeEYOV/k3LG2oi2i4cNpWESDwkX7m+d+YnNzo+nytqESFCa4L283wTWXzfK8du6SmYlnWs645JOvMMVSa1w7s2HqhjPWaOy7RWQeuNZzcn7wrHXu//X+XYIfH7588URH9BbP+v8d/lyCF6/+sqpv8d8SvHn66smLV98F91/zbe5agicv3j189PLpX9LsW9yzmLo3/oqGrzrErHX173GnsYGX7v1UKS0Ublm5KtvQBoW/OczOS25eZ1A2IncMWgO36cqO23cZJPdAOC0amhfXELyBwNlJf2hiAR9qPhQNEprSvfC/1kaDn4QmFsteZJVnjc/LyNnSe5Z8t7m5QbtlMbt+R2cTdVLLcbKNUtxOEKmaK78bEepccS1qYh0TBZSaj8/zWWZpXxv1hp8V9TBTVE1rNE9O1NXtE/ZM67TNHKLxHXtYGIr461c8/B1J6Nn9K62y1u5dVeuf7lyNqKV1gry1Gie27kQfZWQjBjMqepEzePmo3M5iPz3CJzP6vn4LLAqbAXXEsXcnyvVpJD4Lv1zIkXPLuIB5k6wvlI+F7XExA4NMl8LI00Po0qPZQzgS4S29aNf3sBjTmm9kJiiTyzCucptPw41e402EONrv1L+Cu7q9LwXqW7qyxQgM5ya6Yweok5f33Tdx872Ig9pzf+Cd36E1wVtaSO0l0ljJ/mRtutg8cIXaqZVG93LET9ZaEwGCERU5y9PZO5gToX9diOUneEfzwDgtxnT29AqaOX0nYg/MxalsLVh5QbMwtoShPREVvtl4MUsZ1aTICWrzopubekezE9TL12pR2OxCiCZb9O9Y5Lfvla1TyTtvTypK1xpXs76ERnP1wjZPBpvVSPPWP7mwPaGv8GxrsHHWfEhnM2lmX6vlH0ZDcygM5PRwL+7QPGvannRsfnNog+L2YOC5YmpMqrbbYXWNZnOkdvv0BFb+m6a+MoIYdb2P0/KywMstKXyRP7ATkVo6WqvDgqBJQsFA132L07qsmzdNK4hSE35Flu6iMHQ3t0FBsXPB7wRf0TuZ3GqotX2p6SPbDgufob2g4cVupfcl6QjCslaTxp0h66B4s6CuurkJWcLUJWM34JtDI5OI4WR7yWErfaBQjOP5dEiVirB27Q1YhBJPmQjCMbDKP5vC9SMLWSQ1ciJkGtxWuHtRi5M/6ZBKLCRpAcTQg+Ric7OQozNUP07pmWeNreOa0PIYuJYz9qosPYo0E5sOaKVqYz6OaGIA1ed3dL3um3zN0/yWs49+EXfu4zScVdA4Y/IiZ8ZJj1c41+ciWGF9zzynoUxpbCZWu9r249v3erTIh1ovKONOpsW1Kvw8/aS6UG+y0VD/XF1AoY1QDf4zxovAt3k06vMfwHIuQIDi9qoc0XqdSrC9g7gCWoHfYyR3txqUKs3PxXyhZN6oWz0TuS/J2mbI76SWadDmhqr900qVD3n9qLyiWdOyRWpsGxcim5vGtqTveMSikXZ3Jm2c84KXMErpXGx3XkuoFTcjWkTxXJ+4+GrKxOucd6xKGZ3aLC1cBak24Ddfoa0sRWnqecL7VWEYSNVgHiAqlYysgO/pf5yGRUR+mIYVKSLHv0ZpYlwlp2ek7H4A651nZXUhnoWxiH9stJFjLO/ISsOrprKxQYcRKVfYBam3U/5zmjeljYeSpulYD2bF3dYt15MIcVSNR1lqnutCK4X2Qr7kRxh/NK+5BIbbJBLmmDDNUzY+9/ZFSweYZ2fExeV6ZLbQiN1BBDlrw+3OEyVSOvpDZn02SlvmkmhGjLDIVl6al222TQvqNudOs+VA8Ow3DaSek7vtANEBZp2eve1xlZlCKhajY6szo6l8nvis8ATrxgvWr1DCKSuvf9tId9D5muCosPxNwbK6a8lu7aHXxVhqWpuDpccqRM9n0cJ5reN8OQ8x0cxzDlnr1sHKaE68Dc8kjFRN9rx1HnW621/LA89e5HaXvaY83Y5Pz5CqMF3tG51cUSYY8hDP3FUb9QDpyFblkxnbSQDzspfTiDy/9Ti748mlhEERnsdzqrSeW+K7Zv6+9ChbcWqppSTr8L8Qg+7SIi09G7ofBqH7JWGEGZ2qUKkYzys+piZs2wiixqGQZpmfXkDhNCk0G3Xbe+nWPShsnEYX5SfarFvWjNpvO/HnX1a2He91EcnojDLa6PZ7akRN2Yre+8vbILH+haPEq0vzol0wbFPd0MjTZKl+b/ThFzJ7wsL14Uw4uK7fcAanYKHx6qYEhgbbVkWfC+ny5sVEdtsPeV3nxTSsIlIYqqszxFKdVmfNnV7sDszSGd8Xk7eyD9ZqJGoIPFJA7TLV/mUtW4Pl5C1pHWC/3h9OjkJFB7k30i29a4ObdYRct6VTyt6CFw2bMbWUD0Ip+lgGbA4/L0mLYpZCADqs5nw/VY7yBwzXFUYE9C134ayM0rBB0kZMWjSXXqxhdHNDjfNqJS+tca6CmadNtXc1WvtOPgk3LOfYeH9RaoHm60TjnejknFa0k1a0U5SWQ5+6o/ZQmoFzHxixDkTR7lxT1lXOrr6uaGfBCVOekIjBfl0uOhfpdecyLViHlR3YnToFvWIdlo8/dkLanXY7i5p2aspO8gtaLljUVeUDCKm/4e6ZzeZgh0YNp0Qd4awj2KJbQTdYmzVHlz8rOtjnDlFLv8xQXZwJf/DOrMT8l38+Ht9y24fZIHobD0S9DFCDrBaJssHhipUiF92a8qbpVlIkG7H9OMvfSghFWSTFzQ3Th29YRpub8BwxIoVTNSKrpU/X3YIkRy7ftxfqsL65MZJExLfn0+osKfSVcqM/7Rq8BxpdpyMobPIJCwvCf3qafovYLsPxW68Oi2QWtk/wiFRJoV8bVuK1ofmk3ZGaQ1R0g2ZsIq1guDVCfrW5KWuQAR30S0IZIb9YHSHfNsRu3w6/7UmbAr/mws9CeaTQljXJD618Epoz/bTwbFk/LGrWqRdc0u2k0rma16daR/saKraCr/kGFmlZ8tn/Jlky9d7juoeDw0Yu6vN2QUppayx3qEhmuC+JIS9qWrk8n02J9M5LSc/o/Vx6bpNgfMLkQ8/EvS8ZrKUF8Z3I/PeIiytIVVcQdxyKPzM31ngXKXaqtQIhKi/Rd3sK+VeImL7LAHKrXJmysIqwkv6/jzjZ3iAgmkuPgnosN/4XCY2nZ/9bhEY971tcklBHSpTq3wG1pcQ/ISNqClbY9KwWEMlG/G+VEX0bxn2KhWlVpdf/BWKh8Ou3vkCYsg44n+Hi4NqioN15Tb+bnOOj8GddUcqV75BUZeoRode8liUeQWQZta4HGQtyXRHNu9bq8oKupIWLY+wvEXF1MzzHcKO+/z7Mu5pqgw6w7opzvwdxzZZqbpfQpEz2XyeS+Xaf26Sw9quj6DNt3P2sNGhpv/vRktQf00QGt+PHYTn7RENx8f9olYhlvGNpAcsRqaquuKtl4lVX1f2QKf8dEHul6oIx7kXOlA1eBV4+AHo+DT8vCbzZJvDEOiLVStcxDyeMVj/m9NLvQaYpuq3HjK7vtuRefIKs7SvmL/cHc3p2nw26Ja45b5FeJHdj5r03lpYK849pl53TInR2lyJh3Q/8lHws9Gq0CoVH4+hYWxnDqnckY+EgR2eJyItpqCECooD2NNLC1TiSP8MrQ5tRNJlDXzsbvTjl/Kxox7o3rGv0FalI2d5f5eZmaeOX3RSRsEpC6GnTwkj7wKPg+Y6LElLwrEjcaDh263RvQ8wPDrXLRMcOEyvdtm5u3hoy4L/I4/8yCis+01pnZxWRas3Z53a34+fq/hYVmM17J4lnqvvrX3+yi7YD790u9XraUDTwIjufBqEeRYLNMSPR3ikK70Yu8na9Hjo7e0R5NDaLyDhAa5G0CPOaJ6qotJLAY2VPBY82jGkqa8QvCKnHGT1zndG75RJ4uiiIVae9MPmnEdmIhbtmt2fe2hK/Nj6pxbxoavtkwipDZwEiv3FK9FdWiIhV8bHxfute5eVReKBUNr74W8PcVwyZtvn15m1IZ3hB+V3/QQBoouxYh84SkSZagnGQvr6+aw8EZ9zUX/DBFtzm06sx9TyaagkGJAXfzlhsniMuENNMxFMWW5YjWoM8nXaEDbkJr9PRU77b6ZxU10KuVrXobL9+XfOirKCVKdEJnNg7AWhHaJp1O52nV+nFfEZ1RJ1OZ+0IQGsH9rnHSD6rIvbocD2mLa8r0slBF/Hr11lnln+kvOtTWAVqAPJiKhQYeCAIF9zycQoGRlyMY7xra5YWWTorC9rJCzW20q8r6sE/0ad3i5bkCSpUn5eXP5SVfhsUdE5tOs+S4LNpx6DDqgVduiMlg0J1rfBOa8384L5nPsTIkoI1PK2DD2Y5oMEG4jrxoPNeuMW1wmzJKd8pJ5q0sKKpWCG13NIiNGbB1rvpVtBA3x90OmIfVHjEmuNEj6gVCqoTMnoxn6WMbmdV/okWLfU8nUJnXwjF3dpd/fUL05S8Ft3LOzEvZJSxDkunpENzdk6rDjunTkgS7ZS6poz3MM/BiynCFJOnsgn5JuukdefXr80U+vXr5mLoNhYDH5YVQbDM9MaRsMxcV1j662JZb9aLWX6hR+wOW7w70cWIO7P99t181fQ18785eeUE++IZXNNOylfiYpZWerLgetRscAi+25xehhH5/c431M2XOdI/AlxJGy93SQHPdBwPQtXKK+RV/j8FcykHC10gMOWAoJn0aHpz8920fQaFQr/0ZBqRn9r0S7+s7iBSKofO7V2UG0mdXnbeT0lulGFC7ZRLrkrpmHLUqbkbKri4uTk9k59dB02VTLNDDtvCBejmI/Se+th1QwhR5SgJfrRDyl2mdYevn3lVfsozsdekhbxaaIk3J5/aC86WVOpHKX+Y+Mm+aFnQscdgVFSzagEBW5Pk03RY/H/sfQtz2zby+FeReTmXmkIKqZdl+dRe4iSNGydxE1+aK/+aDCVCFBsKYElItqLou/8HD5IAHxJlK23zu0w4sbgA8VjsYhfYXWBIBro3JOCVm9n4TtVNL/MZ3NR/1EO2XoZAo1KYKg+oRvWF8cLzScND2Uv02CWOMCq8SC8ckvpAx8UFThYRwfN9isNDwg51wZ8/h58/o8+fdV4uv9nPc6re78eodqN7ANeBt+Mc6ziGOL/7zvjwGQ5F8HLWzA6dmOlk84FeB5qXbJSLGEfZppjEGOfu+qM0CXNH9zPG1erJfrggJiETzmI7Hmp60TMqXGIL/ufPR0+Zvac5WYSUjfjCj91Vx6w5Hrzh0ikT3yjFyrAq6pn8Qynp8Od2J1aTyqd2bz0rW54Vfyw/OHtgJQmH2U39+g/RVubbv+Yc7fzcvudR2rl9kIITCBOyhrLHQLz1scVQWMl0EV8ZE71NVDs9Ps6fZZfhgwKuSHfN4wCizCQ0PDK+6DZIcln5fjshco8LwgNlYv/8+UgYykWhnz8rr81ULS4cj+KKLlyl/UDC3n67/kW220Qq5IlAHepYRJTciyDfd15UT7EWeKSXKXt/uHU1xl9OfOL++JNbsmCOia+wzGrKZZFemetQ4UXbCTkqo44Kb8OWU4u5S7SWZuCNK1i05hpX6AKhbqT/mt+EJgXbx/yQo1wAeeEWfkYlKPdBh81Up1DkOQiHmjYcUn0YHR9rU9uPoHY0HKKi5obHx0dEOpY9DjPNgvT64Chk1vNMVhkmwk1jT98btw5+cdXY7geZ9xfu8H2oryGa2EG08NmhTIMWiMjKh9HA0prIbfCrf9YBjjyWHEKf3Ztz5nhR4NurwdjHk49nY3zbiLxPHnIHYxw6MGyM8e0mLaDmeEsgvbIVuQyIAhutd5ZizTzHgWi0jmtHGEEpQ/qrEUE7nMwoTmoSdBJvBjMgU18zMNayNQ7siUdWA7O4cBxABJ3CgtefGtyDwzSMkq/j4duvYYFvT+AM+w4MwQGLZbB14waOP3qksYhgKL5luD1rzPGnImiUB+YAk0UY4XDgwKm98EkFXNhhiG8aN6EdBDBcV/mc+zuJzyUMlRFI8ZBNsI/DwT/a7XamzQmVT314e4YXxPcQHBhneAnDqY9vBpwez/LsceM5ZEZp4J+7ai8ambVSL/1PocT7ULRxv3J+4KVJnEozQUQoq56N7clHN8QL5HAK4Fw8MPj8MLMdfMMTUlRmEH4/vGXbORhQSmWHQuxFEVXKtkJoOxj5q9GX4R6OCeMssB2H4tkomec85PqwjCX2nAaWXuSNPZ/SCafsbXVWrqB4utqzEKmVNzOPwEYU2BM4QJhOFzmGJPCWNBIg9H0viLzoIL1JYVKqN8GoilC6Q1Wc4ZIZxh5H2F8QeObDKRkYxQwjVTBf+MQLFAqJ59wf/owux/VXn/vodMeEwID+d6BSt5LPwetIExX59mURVz5KYo4NsIcIDA9ZHSdOLqDOYs2ndcgaZKGeZ4JE2crO6GzOz6oSAgHl4vokuD37EpP51talkIQqPESlY4Pr1lOM6MzxCQ7MfnB7xlJm0HNnpEApCDyEYNjwsU0RJrTo0Ha8RTToGv+UOxqXQX/P7dD1UCNkkG5wK1dqBLcFGGMzLEU+IoPG6enpKZwLcd8gOBi0gttahH3PqYXu2NZ7PcCfZqseZ+OVVcg4xoTgeZWcbE5M8/2j06L/kiEloY0iuuAesF++TeBvulE/K4PH39nIm/PVUbMf1egA2GHNQ1MPeQTWKK77ZxXybB+sgT0lewzZ5t9x6z7C1TS05zDitayNf67zHQ4xO2pM6WwC21DxUf5Ru2c40C34UiRsNv/+G7Qhg9zCtUT5BMDI2fY9Fw0mkOX5M+YBpZEpZC3a2YBLiEjEyyqcGwRBGKm2mO3ZRhsBxyb2YL3ZSLeB/Ve+ZusPTzeApUO9rtfBFdYNYDCbDf/PBBpdnWvAsjQ79OwG17E0oJFwAbURsDTmmaMBTRE7NcqN2mjES7Es9keb+N7kI4Vmz+zgXvFHsflNZBRxaeFQHNXOXD4ROzcdcUQyf0O2Sc9WIrek+cCbB7438Uj9+Disg3CTdqZeB6Kbnzy9YYqmaf/v1jnRRmniFdZbpTjIdda3x9BPOlrwn1JrO65UAxqtU3ym2p6gTkAbGICU9q3Jaq1v6unVaT+XjulrOqZpm4ykVm6ZS0p4X50qOkBzvGUhQigqLKslYSi96Ip+W4ypFEmstZaliTXhJe3otfAh0EAr/ly05r+u8qXZOzk5aZk9qfQW//MzzTinA9DtGL2TVlzKMxtYT9AIrJEb1/J6QXzuNg5vycAyaFcK07QRyKYMLDOfXRtxIqyDZ57eAWuPwPnAAEzqD0zAxnLQ2tRHoNDpNiX7s5gy6N8Oo5A8afCT6xC/L+mCwHlhLk5AAPEfcXs/f/Y8nQCzXt8U0KRRUmNysoVMj3BZmZpapbxTQiAFwyy4+b0Y5hZonfS7rX48zC/ZMINXCJCQDfYzHL6eisFlv9NB2sI2eZy0BE7iiSm+LZ0iPqpvsjxGSrFSlUvRthLK6Z8sOWLMv5r+W5z+o5QBNnugvJglTMESbNpOhoAH9MmcQOmdLUSUWSU/SmF12jUKZ0JVudsuHYqHGe/DPoXiSVlm8Fm5DzTiER9qwNg1DV9h3byHIsAqrywV87K4VC7Srl/Qtmmawnf8djjfv4a3BGhaXZmLvOrILJH13NK1p7A3qwp7c19h7997GllUR0mxsOcY4XRlAi3EnKyAEP0CYRnZn0mNOTWfyg4NK/youKTJzPNLKpnb4UepChNonsMZIKOVAvE6x4sIOvgGZUB4yfmoTHcFWFZRt2myuEmw6/qQzkkiCq5AdZUaon6OmkHIFgdPuI6ky/lZK7PVYUSrek7TyusrVpUz+hh3Ci1XyLxlRYXMX/7tFDL658HABGIjC3Ar4jUM54P2YbWzgpTC3KwlAInI/iRaKJ9xIo4K+xE1Y+7J6XQDJAz299P2kqo0zqQDLWbMbbphYWLM/1vrAUfbUwuT+VxaVC4L2UrlBtNFLr2IX1vI9TbAQxkLPo5v5slXOCNz/0LVgKPqU2w7kTpVRMtW2SxN0cR295RYrYzEKli5fqd9B77TvisTZ8VcwRUz23GubZdK6DqIeUWlbRl99r1l3ORQMg5YQr5pstQrlzKpaJEEB6i6B1IsR8on95SEF4g2g0kVIRKKpQ/nu2vb1feY+dnQlU37UdVp3/4bTfvS/G7cZX7PzMuoSVIU7Z5bj3ZNQwo3BHupsKW0XCtQzb6QOpt2DmHyDC+Qwzhf7tTs3izu7MPiZb2sQPyvki6UcUBQlQNmf1sOuO8yfCtvoAwGZQbJDOr0K6Z1sgrgNX4r8Jqhd/fe9L7cR6e4B71fK90oo/npTpoXeHT3pflCYr/jFl176xDtpMbVV0yNPrbZfS1ZQpzfmxDHf9LEe5n2oJwOV1Xn3vn/5tzr55G4heA/7EHwbUbhTogDB9+gRmAj6GfpP5Mq6c4Z35Bkj6af36PhztmpFh1NQuz72fdr/BQ5KRAvSOQ58Lx0f+dOSnjBjozn6RC06s2ZjRwfvoxz6Uio4aL16kc6ZgEvVzgkzFowjHOLvuW0dgbmwTBqVt7t4vwsTf1IQUv2q4mPI5iuC54uwXliOlBtKm9sYJEQoBA8ReAt5Z6P7IwGyivsF+OMcw5jDHHOoTEfMDuN2Tf7vVaH7SJ2RiNKxi6w3iLwnoD3U/DzlJZutcBv9mgUmw5oDeyXNgKpvswqSV+1EUjs4ZTe4hdtBOwggMi5xgOrDbT4RRuB8WI6heGjOV4gMrA6QJMB2ggsvZAsbP8tQ+zA6gJNgWgjMIO2A8OYyQZWD2gqSBuBKcZEznMCNBVEMbTmJDOISQfw0RzExAGk0R0oZADk4R2og72R9xDaMSsb+0/R5aJ+IailexALXHk9E1HPCTB77X4nruYyrobVcRFXcFGhdCMu2hFFnx6+6GXMS+bhyx7HZbf3Lbu6la1otkdNNtnDqC4Z4dIFbeySzOY4JUXecWvGpV4JNgWoGXMmQE2ZEQFqKmwHUFPlMSoAFYbiDeuyhilTLk844WbDGb55xHaoOPQ0gb7CLDNbvuh1nmqaSbKsKyfJfG9LCF5+vXcpUuLTdbM7BcXDwCRwM5aZEuYy2483GTHeAtY7T++dmEa/3+tQqlknOKcDybSQd57eMVq9btvsd0ALrHk7L5g7vbHZ4iLTLbaDZhw9ZeE/syPhMcLFfmbTbJeA3iWSZW+hErFcvO0lz4zsv365s4vas90z5xXWOxVWDJLba+U1QjezRqg0icKDT6Jy6ei+8+gV1s0qKyzmiFx5BBjrUio0RsDSJArXgJkuLDReKK1J7P1O8HyMx/iW7QfTRaQGNL4AELZ1e0EwJTofEmELTYyN7Cexx8ygwwF9oIXQdl4jf5UAUnOpAAgGEQUwuzu8DWzkQEeF4hsUqRB+0osDowlEjo2Iqk8LlMU68RRPFlH6OvYX8o41C5rcX1vmdWQVTHFKNVOZTbMuLsHhmilvRoH1kpb0jCYmSixrYknOx/4iTDKK1mdNqBHBwVWIA9u1eUzk9p3wcioP7yx2KxWP4+K79+GiXhV7keKQWp2dTrIOMaVlVytzKzo+xOjYe1KppuTQzhwVeQmx81Zl567kVGpZXdj+HfdIynyoqgoC1k20i3Mf2mGiVvBavOh1AFFFfYHrYzM7EtsBqSokiRlJqYm9a2TFAmha4iv4DIcXDjN2jC+YefqIdjCOt6WfxSZfZR8iaXby40e5hgEf6SSJWWAljYlbXnNgSYcUOQrThHl2wHc66huKqfPl7gBoVdUtDlE+ywemJOGWUoBWGq1idI3EvzyOUmvwFRwtmd30vcnXXsuDGqyvazUaW3iFU2FUHJl9Nrdv4xiSVscIbpMAusaKfbZP5Swhdjm4Z3DenlV6uCRo/Czj8K/i589uY60589yZT9ENnTULrbnhyD8xDF6VAyc45AS4QA4MfU9EC+xfW8J9RRHU2eI40TVmOCLrLA4yNFEQNaGi9U4UzfPQ9jZEJPGa4GBg5OMbk+gX+jvHcYWFE0xsvyEiaNeiKErtSTB0cXTE7V6ulwXqaNIQviytLknBFl16x9YM20s7iHGlipezut7ObyG/PRgK+UL+/yAKMzsUORQ+LVy+p4tzE6wFyzz14Rwi8gZOC5fwnMe2ZWqDteCSTK4qCtmtUMg691BPu/KCLN7gTNZi7e0UIs+D0oRWmWR6rPI2r1zgQV0J8trFzoUyq1QLabnC+gmrxOSViHGTKjEzleTnxV01ibauEXYgU8sGDRNwLziuWoWQSpYrCUIXox5yk9x4QYIFSV7ZEUHJ29S33WjQB8zv7hl7MQA/5vNcBrH0l+xYQeeXBQw9SKFzFbDeyJDVhUPzhHAKQ4gmPJ0fyg6RaA9rMCv7nG3OG3Hro4E1in/HbeAdYSmQEzT/XhwTGfI3Ztdjv/6gjRAKaFztYM21NWNTkQ/exgsT48ssTLhhLzPxcq2d7wjmJpQqpfbEnqi0nSrviSoJdCXjqSsfoUpfLysciq4eTZi9b2YDoHJFAF1PvPMciK9De/IxypwYGhc6hE2CL/HE9uElvoHhuR2x47yab+ybSw8Vpkr3aPzQMIvq/WnhOfB8ZiME/WzNJVWKgyCl64mbT7h69Mqew6IrwOpr4Qy8u43HxzoaHhnsSoDm+5eX1+8unlT/CiBxsu5F0YLHSBY8lkanzAJ96ONe0TDe3GVTNdO3NKD1Osn+WBRONGbjK5zDtoZ85KIjKCE2LyYYvcWLcKJ6jr7eM0RKcPDHxM55R0kmO9DWNKDVGj+wP9xlo9xbo6RHW5QI6QvGJPyTV+woTTX5lbgqJEHO1dc2mo/uNppXBx/NLzqMuXF69bWN05O7jdOrL8J1oy32HENytmcYYrF6z69fXkoaWR5PX2jgmbBJ+Tf1jM/kuwohIStZqCjYf/O1kcu7u5HLm/uSS850+fcihx3D/HIvZ0Q6thZdUWFmrKq8A58LMJFIxvaJBjShHdVoB5XYT2/uNqb+wmNeWJyYtBkhQTR4+HDp2fKeM1VFH/Y6t5T4QJYWKzUyd0wDcaqH0OQmhdTgF3mfKL66pZa+xCy3e+WXs/fu08ZueRvv2SzVINTas12qyadlSMZ+1ji6IGNWEA1o7IINikgKfMdbqF08yUYMi68plO0lP15pQMsoN3Ikju9FhBljc+6E/Jy1TDCoSKNYs+kiqjg554mofmy7Ll2TF6emNpDidH5saHFaSZhs5lC/TOoCEX4ldgZeDA3EtdoZsOOFZJWBsYPJMzAPFUHFrWU5Dw5x68i5MBzHhuSPcHU3v8v4wwKvy37sdfkCrp7IPpdqG3KulxM+gzXTRebFk2HqGHKzBC/EWRJ90DntddpdoWWYJkAusIgLrH6MjfjHGwQ+TcFTVOipmDAFc1RMWYSnMM5gjoopn4yAYAXmqBizxUgEpj5DzEcxfkkl3TtPb7e73U6n3WJuPmrUZ7z/l2ZpsSxK0Gg+UxuslaNC8jk6YJ03f+azdcE64yWZy9ID64yTZC7LCVhnI0rymfpgXeTsn894CtYFPtL5fKYB1lKQV5yhZ7RPT05PTnqUONbIje/4Mjd18MHTTaMlFBXHBfmLQSw42gALuSO+BW2C3ol50klUm99cNrlnKC390QOOOxqBNTv3mxEcv6VCdiJVeYG3qmV0hHPmjSv059/iNmRcGd7QJnTAjSsLlqzHfjt1yxe62muhq7UyrgvPpsCimlppUWauqEdxURlPpeelRVH1oH8vIdc63UPK5fW2u8q8zILgm8z7JvOyMq9t3FPoyTucZWKvbXzdcq+1W/CZ7SqSz+zsFH1mt5rsM3u7hZ95slv6mf0q4s88rSr/WkZFAdgydwjAVuu+ArDT/usFYKd7BwFodnJi60lsHD3ZVwK2cmW9i8s63UMEdvN7AvssP/O7ANn1J7MSJjKpLwDQqbYK7d5rBd/dsoQ/TPPut3jfsnpPmqHJewxya8urqGYv7AsDXmJCEytxpofkV9YA5Y1uIp6DRzoUrZfEZiW3P7qy1axQIRJVZxWcpGrF7sbL7rSVylW5VdHGqRYhvn61mI9jt8eukuHaIz6MjaAmsI5YoGS/noZcxIBEsQKlWfiRJ8mr5CcZg4RTZPyaOE/GgFgR4oBWu94UcXT/iVWhXMp1CfxKqEO5hCdUIcpB2R1MOegFV4ryhXO1aCSI5jRFHdVWVMRQSAZ5xZlk9NH3LP4oTEYgfVcxSCEqCjvdMhRKKdclcBWFUoKEQgkqoVCCKiiUC1dQ2FX57rngtq5Kzs/sJQ49AmNT/O9lpvj4jrUZIUFyvVroD5+wP99rD+3Ae8h4+EPEeDPSimz3LiQS/0b528RqSS3sEvW4nrpqaHcheeT7eRs752F+vdTZ1gK/1x4KHERavRl4AdR/Uszr6W3sdiAq0kl9U8+0JE0tviJ+bgd6/iooqJr3s5n4199p330PuZH/+++07zb15u/YQ7oGalr9LKkgP1EOyfdaTf/XBDvwB+17GJv8v9f+9ZDB6hqAzLQQHR/rUDIyDAXYMkZNPoh1ADesw8i9QL/DCaGs8QROhw7U11N7QnC4Krj1D8EbSjJEx1OKL4I/QjSAsQONc4EGWogxoYoUcy24vBfVMSG1i+okgXVPqst6lOxFc4R9vJviWCUl9MbSqlFbknBtu9HxMf9raWTpNnzsYm2Up4Bsjj+JBP6zHCJd+8V89larg+el9MBXvgyhvofgIngLw6VHG86Jw00nlziFxHeeJgQQpyCegiBz9lkkjMxuNV42X48jGC5pd6t6IUntejDMN5ISA69JN+tSe+N5THyT70NmvtPrUpc4OYpP851UiFbPEJPtOKLMa8wbJveGTgXYh00fu7r2yHFqYsLUitFWL8Mmv/CUDvKzO7oQfdrrKDwScktjEDQ4+hshvmGqck4tfrkEF6lF2Oz0+knA+fWSauprXgJbFvKfLI4/wTvbk5DetRFQhpTtTCgQbQQEHtnuRIzTZBdi7Olm2zROWuAPG1hv0KgIVD3iOmdUR+7FFLwIWbIp1LB6M7kaQVeU/gf1epy3JRQiNa9Kv/XC0yXzzsmPvzZvg5/u5m3w+H/CJeyPr200f73baP7xlbuE/fa1jdMvdxun3765hB3CJezB10YuL+5GLg/+t13C/ruHS5hRcExHcoRF7Ld11yOIZ2bFvVGJPb97aSPbhTWucdaSs4VLOdU0CgLG2JKmEcIowCjylvCuh3EYpigrX3rlItVNX7MHNMJtr1W3jXu5g1WYPnwnzywj5wM4wRVPg77Cen+HP2HlspQrHmLXwX9kZuT8SR8HqY7b0NWa8laHQ9TE1K4a07uzFebtCIeokMmJ2nm8AKlvP/HhIFU+f5Kt58sQSbytmb2X68vQyNsZvolq7CSWTH0qpfTp4nSMnVVFftwqtj7FLi2d+5+URpuqTjx9Y795o9XbMXHs4zzcUmeh3p5+NypJdat75n6tPiKZw3gyp+/geRzvHhE7JIUpEDmHOZ+Hn2R5Wm9+4A4m7DwdHTWJHbqQKIf1FJzAk3yNkbCgJAfRZ3tRVq2U8S3NWFAAzB12Wfj5U+QUN3yHk0x2A0w1GQ6LDw+jjJwxzC/5OZb8+Eo34zpQ1StiKTwS2n8Dt8D2Xm6BVHXr3GceaHfL54FvrP+FWL/duw/r06/vxPqs2ruzfvbzg7O+PYfljN/ufUnG7//1jN8x9mT8jro4bLX24/xOK+e4+y2+5Juv7V/ia9tp39HXNjeX7I406bS/bpfbb6Emf2moSYHlcV/n2+7JXy9tuqcHiT75Sayve+a9o09+jYtq7+F62+vcSwb2unvIwG/RJ98k4p8mEXu9Q0nEKmEovd7XLRO/haH8PcJQDiAc+8ZfLxz7rcNEpvwiRFq/c//IlBdxWb09xGP/XnvE/S17xLtjK77e7aJJ5p3vF+19J3XRBM2j6dneLa813UERGN2x+dMv2vfdVyQ8f1K+z9LPKIbTeJ/lThssU8FRp3+DndXTfXdWT++1s3q6e2f1G7tUYZfT3t3Z5bRor3RfdontpOVMc9r7IkzzN9iVNI19tyVNI+e0sg/bmEbOTegwEX1KHe3s8cj7NTHnajBeEILV+xjGBNXGBFEWndvhKmmcVfWK6oQzCq6Qky/eyfunb71nQzHKP3KcIvfKkksO1Pv2kXsxbaqRhG0eTrXduCey9rdnTXzyWHQic69mv5h/dbe71Rn7jkGY3ZPiJuWjMXu9uE3sF2vTSX+H0/eBojX7RnErM2Gb/L6MkvGI49xOSwYhDXjb6T3HqCAdLeZXwH3gS6Mo2yVRlO2yKMp2YRRluzCKsl0SRdnORVEKOuzGDe4YpTGLRknMolEWs2gUxiwahTGLRknMolHc4E4rjfrstLMBnRSSifosziRHfdL3bNQnhclRn/RdjfqkEDXqs3tahkEp5boErmJQSpAwKEElDEpQBYNy4UrUZ6+borDXy2KHQjIoLM4ko5C+Z1FIYTIK6buKQgpRUdhvlaFQSrkugasolBIkFEpQCYUSVEGhXLiCwn7C56elfH5awuenZXx+Wsjnp4V8flrC56clfH6a8LlplDK6nHRdlqC2WU6RGi2DpVbLYKXZSgWi3bID8s97um2Ljbz/3tlt+z7hVCIYyigMnBKRf/X0UmRa0Pvl8Besy+Foc+a0HGrg+bJAU959LmdRUXkN7+cleFYS2/Z8CaybKfh9CS6Xsq5b4oOedAes2WNRTlndLZSPrKr3tJd31XYaUx/e1uh/jQn2F3PEf8+dRohvarbvuYhf5tCYQERgWAsa7VrAMnRq83GjXRu7DXaHTy258YcQPK9FM9vBN41ofkcP9jbQZl31lgl7ObbDxji0kVObrxpGbR7SdtgLgmvSRT4NhMO57dfEfUPCZrIgMLz00EcNaA8Pq2HHt01jxG71LVap+eXKMmfNHGDZDridpcsysRBcp61l7CY1vsDTNH/qinI0rGJmchoeopTeYJcEieElOGCZ+JU+GtDahnRarB1FkEQPfeziZrR0lbNhaca9vXtr19D3V9kAoIyfvsmGWxn++arRosM+d5KRb+91q4iyirOVsoNGq8avfrLDjwUEE4eqjpg9UuMbC8mtkLMQTnlEzuHo6SSlJ9Tka0aAmhMS+i/gCqDmHBKb/4pm3pS8gKsyssuakJ2E7j7Ye9GaMoqXAiPqRtYhsPyQz8F/JrJN42DYNrNGiUOiu/ZSiKetART74v0ffyqq24dDdfZkssOg+hyjqedmUdzNKQ07UMyRlxy27XpkthizM7YJnf/Ikv/lu1MC79qHsW+jj3eJPWHFZxt9Unz9lkBFA/NrsnbsZlFM90HLbJ2eJhdxrRxgLR3wBIHHRLb37lJ+KKFqD7X0TptkapXuzslOBNK9nNo/4rc+U6PyNaSbLHWx/5u80hFJLwcVurSai76n2RhfcXg7k68t8oljftAq0UnZKRzgXXRnTZQXkB8TsgJwFeufnVOzm4zGu0jJXpd/yzpmuFKv+MGZdy/z7mfeF5n3KPNuZ94nmfdgNczOG9LpJj/7+psIWO+iURHqZNAUhzo/92e9AWhojQCdYQAeGmf4X1Bch3SGv/+ez0veEFp4dOY12aEpw+EwIMfHR8ZwOPS4MzKfoow6MI2T9knH7Lc6x16TXbF1fIyawSKa6eLrOvD4tT5DDIj1IEzgo6EnTjVJDnFhgxBfchU9Xr2AqwFJAQMI5thZUPUeAS96gzEZhJuNbv0H612zRTnrJ8J28a1nDng9Be+XAK3oZNwGj8kI/EpGdfAfrHd6Rh+4U7CcAus3G1wR4EyllNWUPpY7BVMB7potAyympUaFlfx5MKWPxSE9s9MBk6mYdAI532xKH2sylXI+dkTOmZzzkwPmU2A9dsAllMB4Sh/rkyM3MgSTkHmTLcKRlPeRDV7ZwFqEwGqBK1tO+jSljyVBfp7SR4a8n9JHhpy79LGkqq8JuCAKhIQgChUICoEdKuU8mIAXEzoMEhbehQILDyZyOyfgp4lSmjvJSFUQAgw84INFMj6UT55PBPMA+vbLRA/5rz8mepydjuJvNnhPKDX8ZtPn0wS8IhRdjycyupYT+ljuBLwX5GS2u72+AcYT+iQ9YZmvJ/SxljRJ6uA5Eh28lqHziYCO5W5HiD5WXBnr+O0MvGGSW8p349BHJrtxTEw3jtLQc4c+VO5fI/CGgEsIxnJJHxz6yIi+dcBr/sUDG7yV6e3SAb87wHonwx6RUka5jFvCpo1Wu90D4yl9rBz8w5Q+eThe0ScP91f0ycO9FX3y8GhFnzx8saJPHh6u6JOH2yv65OG/2vQpKMelTx7+i0ufPPyBS58E3uqACQE4UCAuArnzr6wLR2dknYwMeOfQx4onEfbpWwKKbqazdDSEYDbRtSDEY6iB6aTOXic4hNd0/o404OnrDXAmQEefP1ujejOEzmIC9eKb7izSRPYcjoaEz/8AUilbr9fzTa9NJ5s6eOnopD7i99JtmAnfRSMgURp4SuhDU96SUUziZrffAR8Qfaz3hLLwJaQoe0wz57AbhPSxPqA83QT0oTOpF4wkhD11wCOHwW1nlLbljwD8GsjIXjr0EYBWtwfeOmC9iOBzO5oNjoyNMoAfbHDlAGtu0/nmxh7JTAbObfpYH+wU9IbQR6rtGoErBKw3bML6iOQGI6eAOKx1YJPZQNNACPklmNd4kKiWgCayOzAH2nTh+9oGiPxxhmRfcnA+zSTGSqiU5/lyMxqpPbYd8MShiKeYWzq0h5dQTEjIociyWgA7zG8COqPc8Hx06EPH/inPZBdkmqzok+epNxF9pLFxpkB7//bNs8b16xdPX2ly0pQmNUoSiSv7D96SgfYK1/hNrlMK04DqN0hzXK8CWCO4xi0aGuCWDp72yHHY5xqQvAgH2iV/aTabGpj40A4f+T5PYZfr12zf14CwfryTb7wcHJkbub0BAUcGBYyoHq7Xz55EzSDEzoKRx/GxRCjeVJ+hOpmF+IYpm0/DEIe6dm4jhEkNIlpXjX5bm2MH1uwp2+r0bTLF4bwWQbIImlr9LEDDI3Oj10EY6PXmGGMSkdAOXjI97hnX+/RgVW9OKLkVHR0YHwIHWQPYgSvg0/RFMMhqxtoigrWIhN6EaGekiZPD84ZanFUbDumA4Gnt7Wo+xv7xMf8rZf78Wfv3v9NXbbMRl+uORvWz/x8AAP//fValtXCOBgA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/6RTXW/TMBR9768wfh2NRze2DMVBsK9uE3RDA6q9ec5N4+CP1PcmXfrrURs+tAlNIJ6Sc67P8T1X19mLImjqG2AVOZuPss2HWeUXkoPnGwJUkY8YyxyQYrpSEYEkb6kcp3xbIEMW8luwts/EADb0vUJgVYRScsF/O3jlQPLOwKoJkTjTwRN4knxlCqpkAZ3RMN6Cl8x4Q0bZMWplQb4abKzx31gEK7nRwXO2aV9y49QCxMN44IZ7S9VtYGJ0eNvJCc9Hj/VIvQWsAOinoiJq8I0QLUJSBk9qBRgcJDo4EcGCQkDRvU4mya7QiAKDNUWiETkznmARDfWSY6X20v3xyr87PrR+Z/5x9/NVoa+7y46WF9O9elbjUeOv/PJoOT9IL9y8m52vJ5ftWTg1x/VtWvd3N/PJmjMdA2KIZmG85MoH37vQ4tMx/H+MR2f+HGZ6777eTlV/1OCHdNmvT6+udRqK6f4Jztp1ATX5uDM7oxM30xdffLX4BDf753fvp4ftStflwTNhno0yMNuu8kwM25jdh6LfDkE1zTiGQHkmfv2OMtTRNPRjMQgeSNSqUwPLGUYteWw9GQdJvbUdSvnfCJtg+9JYi/8udcr4JyoxJMnE8Py+BwAA//+4MjUqjwMAAA==\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") } From 7560013296af2164994f4257181e1bbde9248d53 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 25 Aug 2018 00:19:26 -0700 Subject: [PATCH 058/182] Run migrations as needed automatically --- context/context.go | 25 ++++++++++++++++++++++++- 1 file changed, 24 insertions(+), 1 deletion(-) diff --git a/context/context.go b/context/context.go index ef4d8d1..94501c1 100644 --- a/context/context.go +++ b/context/context.go @@ -7,7 +7,9 @@ import ( "github.com/jmoiron/sqlx" _ "github.com/mattn/go-sqlite3" + "github.com/pressly/goose" "github.com/sirupsen/logrus" + "github.com/spf13/viper" "github.com/tellytv/telly/models" ) @@ -40,6 +42,15 @@ func NewCContext() (*CContext, error) { theCtx := ctx.Background() log := &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.InfoLevel, + } + + gooseLog := &logrus.Logger{ Out: os.Stderr, Formatter: &logrus.TextFormatter{ FullTimestamp: true, @@ -48,13 +59,25 @@ func NewCContext() (*CContext, error) { Level: logrus.DebugLevel, } - sql, dbErr := sqlx.Open("sqlite3", "./telly.db") + sql, dbErr := sqlx.Open("sqlite3", viper.GetString("database.file")) if dbErr != nil { log.WithError(dbErr).Panicln("Unable to open database") } sql.Exec(`PRAGMA foreign_keys = ON;`) + log.Debugln("Checking migrations status and running any required migrations...") + + goose.SetLogger(gooseLog) + + if dialectErr := goose.SetDialect("sqlite3"); dialectErr != nil { + log.WithError(dialectErr).Panicln("error setting migrations dialect") + } + + if statusErr := goose.Status(sql.DB, "./migrations"); statusErr != nil { + log.WithError(statusErr).Panicln("error getting migrations status") + } + api := models.NewAPICollection(theCtx, sql) // lineup := models.NewLineup() From 8f921d6674498c490958d06d16d80f4b96f3ae9a Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 25 Aug 2018 00:19:47 -0700 Subject: [PATCH 059/182] Quick cleanup --- api/tuner.go | 2 +- api/utils.go | 2 +- utils.go | 16 ---------------- utils/main.go | 2 +- 4 files changed, 3 insertions(+), 19 deletions(-) delete mode 100644 utils.go diff --git a/api/tuner.go b/api/tuner.go index aa3e10d..9e81677 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -53,7 +53,7 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup baseAddr := fmt.Sprintf("%s:%d", lineup.ListenAddress, lineup.Port) - if viper.GetBool("discovery.ssdp") { + if lineup.SSDP { if _, ssdpErr := setupSSDP(baseAddr, lineup.Name, lineup.DeviceUUID); ssdpErr != nil { log.WithError(ssdpErr).Errorln("telly cannot advertise over ssdp") } diff --git a/api/utils.go b/api/utils.go index 7bd8a0e..f2fafc3 100644 --- a/api/utils.go +++ b/api/utils.go @@ -111,7 +111,7 @@ func newGin() *gin.Engine { router.Use(cors.Default()) router.Use(gin.Recovery()) - if viper.GetBool("log.logrequests") { + if viper.GetBool("log.requests") { router.Use(ginrus()) } diff --git a/utils.go b/utils.go deleted file mode 100644 index 4110c54..0000000 --- a/utils.go +++ /dev/null @@ -1,16 +0,0 @@ -package main - -import ( - "fmt" - "net" - - "github.com/spf13/viper" -) - -func getTCPAddr(key string) *net.TCPAddr { - addr, addrErr := net.ResolveTCPAddr("tcp", viper.GetString(key)) - if addrErr != nil { - panic(fmt.Errorf("error parsing address %s: %s", viper.GetString(key), addrErr)) - } - return addr -} diff --git a/utils/main.go b/utils/main.go index d448491..a88c30e 100644 --- a/utils/main.go +++ b/utils/main.go @@ -7,7 +7,7 @@ import ( "github.com/spf13/viper" ) -func getTCPAddr(key string) *net.TCPAddr { +func GetTCPAddr(key string) *net.TCPAddr { addr, addrErr := net.ResolveTCPAddr("tcp", viper.GetString(key)) if addrErr != nil { panic(fmt.Errorf("error parsing address %s: %s", viper.GetString(key), addrErr)) From b9e75e1592309b57e878f1fb77600c2a94462033 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 25 Aug 2018 00:20:00 -0700 Subject: [PATCH 060/182] Remove arguments --- main.go | 52 +++++----------------------------------------------- 1 file changed, 5 insertions(+), 47 deletions(-) diff --git a/main.go b/main.go index 94fadde..5bc113a 100644 --- a/main.go +++ b/main.go @@ -14,6 +14,7 @@ import ( "github.com/spf13/viper" "github.com/tellytv/telly/api" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/utils" ) var ( @@ -31,63 +32,20 @@ var ( func main() { - // Discovery flags - flag.Int("discovery.device-id", 12345678, "8 digits used to uniquely identify the device. $(TELLY_DISCOVERY_DEVICE_ID)") - flag.String("discovery.device-friendly-name", "telly", "Name exposed via discovery. Useful if you are running two instances of telly and want to differentiate between them $(TELLY_DISCOVERY_DEVICE_FRIENDLY_NAME)") - flag.String("discovery.device-auth", "telly123", "Only change this if you know what you're doing $(TELLY_DISCOVERY_DEVICE_AUTH)") - flag.String("discovery.device-manufacturer", "Silicondust", "Manufacturer exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MANUFACTURER)") - flag.String("discovery.device-model-number", "HDTC-2US", "Model number exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MODEL_NUMBER)") - flag.String("discovery.device-firmware-name", "hdhomeruntc_atsc", "Firmware name exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_NAME)") - flag.String("discovery.device-firmware-version", "20150826", "Firmware version exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_VERSION)") - flag.Bool("discovery.ssdp", true, "Turn on SSDP announcement of telly to the local network $(TELLY_DISCOVERY_SSDP)") - - // Regex/filtering flags - flag.Bool("filter.regex-inclusive", false, "Whether the provided regex is inclusive (whitelisting) or exclusive (blacklisting). If true (--filter.regex-inclusive), only channels matching the provided regex pattern will be exposed. If false (--no-filter.regex-inclusive), only channels NOT matching the provided pattern will be exposed. $(TELLY_FILTER_REGEX_INCLUSIVE)") - flag.String("filter.regex", ".*", "Use regex to filter for channels that you want. A basic example would be .*UK.*. $(TELLY_FILTER_REGEX)") - // Web flags - flag.StringP("web.listen-address", "l", "localhost:6077", "Address to listen on for web interface and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") - flag.StringP("web.base-address", "b", "localhost:6077", "The address to expose via discovery. Useful with reverse proxy $(TELLY_WEB_BASE_ADDRESS)") + flag.StringP("web.listen-address", "l", "localhost:6077", "Address to listen on for web interface, API and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") // Log flags flag.String("log.level", logrus.InfoLevel.String(), "Only log messages with the given severity or above. Valid levels: [debug, info, warn, error, fatal] $(TELLY_LOG_LEVEL)") flag.Bool("log.requests", false, "Log HTTP requests $(TELLY_LOG_REQUESTS)") - // IPTV flags - flag.String("iptv.playlist", "", "Path to an M3U file on disk or at a URL. $(TELLY_IPTV_PLAYLIST)") - flag.Int("iptv.streams", 1, "Number of concurrent streams allowed $(TELLY_IPTV_STREAMS)") - flag.Int("iptv.starting-channel", 10000, "The channel number to start exposing from. $(TELLY_IPTV_STARTING_CHANNEL)") - flag.Bool("iptv.xmltv-channels", true, "Use channel numbers discovered via XMLTV file, if provided. $(TELLY_IPTV_XMLTV_CHANNELS)") - // Misc flags flag.StringP("config.file", "c", "", "Path to your config file. If not set, configuration is searched for in the current working directory, $HOME/.telly/ and /etc/telly/. If provided, it will override all other arguments and environment variables. $(TELLY_CONFIG_FILE)") + flag.StringP("database.file", "d", "./telly.db", "Path to the SQLite3 database. If not set, defaults to telly.db. $(TELLY_DATABASE_FILE)") flag.Bool("version", false, "Show application version") flag.CommandLine.AddGoFlagSet(fflag.CommandLine) - deprecatedFlags := []string{ - "discovery.device-id", - "discovery.device-friendly-name", - "discovery.device-auth", - "discovery.device-manufacturer", - "discovery.device-model-number", - "discovery.device-firmware-name", - "discovery.device-firmware-version", - "discovery.ssdp", - "iptv.playlist", - "iptv.streams", - "iptv.starting-channel", - "iptv.xmltv-channels", - "filter.regex-inclusive", - "filter.regex", - } - - for _, depFlag := range deprecatedFlags { - if depErr := flag.CommandLine.MarkDeprecated(depFlag, "use the configuration file instead."); depErr != nil { - log.WithError(depErr).Panicf("error marking flag %s as deprecated", depFlag) - } - } - flag.Parse() if bindErr := viper.BindPFlags(flag.CommandLine); bindErr != nil { log.WithError(bindErr).Panicln("error binding flags to viper") @@ -173,11 +131,11 @@ func validateConfig() { return } - if getTCPAddr("web.base-address").IP.IsUnspecified() { + if utils.GetTCPAddr("web.base-address").IP.IsUnspecified() { log.Panicln("base URL is set to 0.0.0.0, this will not work. please use the --web.baseaddress option and set it to the (local) ip address telly is running on.") } - if getTCPAddr("web.listenaddress").IP.IsUnspecified() && getTCPAddr("web.base-address").IP.IsLoopback() { + if utils.GetTCPAddr("web.listenaddress").IP.IsUnspecified() && utils.GetTCPAddr("web.base-address").IP.IsLoopback() { log.Warnln("You are listening on all interfaces but your base URL is localhost (meaning Plex will try and load localhost to access your streams) - is this intended?") } } From bbcc67c6b258ab850227c13e289a714d046dc111 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 25 Aug 2018 19:37:51 -0700 Subject: [PATCH 061/182] Migrate to the new, more generic, video source providers package and general cleanup --- api/guide_source.go | 3 +- api/tuner.go | 10 +- api/utils.go | 12 +-- api/video_source.go | 33 +++---- context/context.go | 63 ++++++++---- internal/providers/eternal.go | 2 +- internal/providers/main.go | 9 -- internal/providers/vaders.go | 3 +- internal/video_providers/m3u.go | 135 ++++++++++++++++++++++++++ internal/video_providers/main.go | 88 +++++++++++++++++ internal/video_providers/xtream.go | 107 +++++++++++++++++++++ migrations/00001_init.sql | 10 +- models/main.go | 20 ---- models/old_lineup.go | 139 ++------------------------- models/video_source.go | 15 +-- models/video_source_track.go | 31 +++--- utils/main.go | 149 +++++++++++++++++++++++++++++ 17 files changed, 590 insertions(+), 239 deletions(-) create mode 100644 internal/video_providers/m3u.go create mode 100644 internal/video_providers/main.go create mode 100644 internal/video_providers/xtream.go diff --git a/api/guide_source.go b/api/guide_source.go index b2f7f92..f3984da 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -6,6 +6,7 @@ import ( "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" "github.com/tellytv/telly/models" + "github.com/tellytv/telly/utils" ) func addGuide(cc *context.CContext, c *gin.Context) { @@ -29,7 +30,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { log.Infoln("Detected passed config is for provider", provider.Name()) - xmlTV, xmlErr := models.GetXMLTV(provider.EPGURL(), false) + xmlTV, xmlErr := utils.GetXMLTV(provider.EPGURL(), false) if xmlErr != nil { log.WithError(xmlErr).Errorln("unable to get XMLTV file") c.AbortWithError(http.StatusBadRequest, xmlErr) diff --git a/api/tuner.go b/api/tuner.go index 9e81677..0174a2e 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -162,14 +162,20 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { log.Infof("Serving channel number %s", channel.ChannelNumber) + streamUrl, streamUrlErr := cc.VideoSourceProviders[channel.VideoTrack.VideoSourceID].StreamURL(channel.VideoTrack.StreamID, "ts") + if streamUrlErr != nil { + c.AbortWithError(http.StatusInternalServerError, streamUrlErr) + return + } + if !viper.IsSet("iptv.ffmpeg") { - c.Redirect(http.StatusMovedPermanently, channel.VideoTrack.StreamURL) + c.Redirect(http.StatusMovedPermanently, streamUrl) return } log.Infoln("Transcoding stream with ffmpeg") - run := exec.Command("ffmpeg", "-re", "-i", channel.VideoTrack.StreamURL, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "-progress", "pipe:2", "pipe:1") + run := exec.Command("ffmpeg", "-re", "-i", streamUrl, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "-progress", "pipe:2", "pipe:1") ffmpegout, err := run.StdoutPipe() if err != nil { log.WithError(err).Errorln("StdoutPipe Error") diff --git a/api/utils.go b/api/utils.go index f2fafc3..897a11a 100644 --- a/api/utils.go +++ b/api/utils.go @@ -10,29 +10,23 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/context" - "github.com/tellytv/telly/internal/m3uplus" "github.com/tellytv/telly/models" + "github.com/tellytv/telly/utils" ) func scanM3U(c *gin.Context) { - reader, m3uErr := models.GetM3U(c.Query("m3u_url"), false) + rawPlaylist, m3uErr := utils.GetM3U(c.Query("m3u_url"), false) if m3uErr != nil { log.WithError(m3uErr).Errorln("unable to get m3u file") c.AbortWithError(http.StatusBadRequest, m3uErr) return } - rawPlaylist, err := m3uplus.Decode(reader) - if err != nil { - log.WithError(err).Errorln("unable to parse m3u file") - c.AbortWithError(http.StatusInternalServerError, err) - } - c.JSON(http.StatusOK, rawPlaylist) } func scanXMLTV(c *gin.Context) { - epg, epgErr := models.GetXMLTV(c.Query("epg_url"), false) + epg, epgErr := utils.GetXMLTV(c.Query("epg_url"), false) if epgErr != nil { c.AbortWithError(http.StatusInternalServerError, epgErr) return diff --git a/api/video_source.go b/api/video_source.go index 69e807c..caaca9e 100644 --- a/api/video_source.go +++ b/api/video_source.go @@ -1,18 +1,17 @@ package api import ( - "encoding/json" "net/http" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" - "github.com/tellytv/telly/internal/m3uplus" "github.com/tellytv/telly/models" ) func getVideoSources(cc *context.CContext, c *gin.Context) { - sources, sourcesErr := cc.API.VideoSource.GetAllVideoSources(true) + sources, sourcesErr := cc.API.VideoSource.GetAllVideoSources(false) if sourcesErr != nil { + log.WithError(sourcesErr).Errorln("error getting all video sources") c.AbortWithError(http.StatusInternalServerError, sourcesErr) return } @@ -34,34 +33,28 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { provider, providerErr := providerCfg.GetProvider() if providerErr != nil { + log.WithError(providerErr).Errorln("error getting provider") c.AbortWithError(http.StatusInternalServerError, providerErr) return } log.Infoln("Detected passed config is for provider", provider.Name()) - reader, m3uErr := models.GetM3U(provider.PlaylistURL(), false) - if m3uErr != nil { - log.WithError(m3uErr).Errorln("unable to get m3u file") - c.AbortWithError(http.StatusBadRequest, m3uErr) - return - } - - rawPlaylist, err := m3uplus.Decode(reader) - if err != nil { - log.WithError(err).Errorln("unable to parse m3u file") - c.AbortWithError(http.StatusInternalServerError, err) + channels, channelsErr := provider.Channels() + if channelsErr != nil { + c.AbortWithError(http.StatusInternalServerError, channelsErr) return } - for _, track := range rawPlaylist.Tracks { - marshalledTags, _ := json.Marshal(track.Tags) + for _, channel := range channels { newTrack, newTrackErr := cc.API.VideoSourceTrack.InsertVideoSourceTrack(models.VideoSourceTrack{ VideoSourceID: newProvider.ID, - Name: track.Name, - Tags: marshalledTags, - RawLine: track.Raw, - StreamURL: track.URI, + Name: channel.Name, + StreamID: channel.StreamID, + Logo: channel.Logo, + Type: string(channel.Type), + Category: channel.Category, + EPGID: channel.EPGID, }) if newTrackErr != nil { log.WithError(newTrackErr).Errorln("Error creating new video source track!") diff --git a/context/context.go b/context/context.go index 94501c1..67a7296 100644 --- a/context/context.go +++ b/context/context.go @@ -10,16 +10,19 @@ import ( "github.com/pressly/goose" "github.com/sirupsen/logrus" "github.com/spf13/viper" + "github.com/tellytv/telly/internal/video_providers" "github.com/tellytv/telly/models" ) // CContext is a context struct that gets passed around the application. type CContext struct { - API *models.APICollection - Ctx ctx.Context - Lineup *models.Lineup - Log *logrus.Logger - Tuners map[int]chan bool + API *models.APICollection + Ctx ctx.Context + Lineup *models.Lineup + Log *logrus.Logger + Tuners map[int]chan bool + GuideSources map[int]models.GuideSource + VideoSourceProviders map[int]video_providers.VideoProvider RawSQL *sqlx.DB } @@ -27,12 +30,14 @@ type CContext struct { // Copy returns a cloned version of the input CContext minus the User and Device fields. func (cc *CContext) Copy() *CContext { return &CContext{ - API: cc.API, - Ctx: cc.Ctx, - Lineup: cc.Lineup, - Log: cc.Log, - Tuners: cc.Tuners, - RawSQL: cc.RawSQL, + API: cc.API, + Ctx: cc.Ctx, + Lineup: cc.Lineup, + Log: cc.Log, + Tuners: cc.Tuners, + GuideSources: cc.GuideSources, + VideoSourceProviders: cc.VideoSourceProviders, + RawSQL: cc.RawSQL, } } @@ -64,7 +69,9 @@ func NewCContext() (*CContext, error) { log.WithError(dbErr).Panicln("Unable to open database") } - sql.Exec(`PRAGMA foreign_keys = ON;`) + if _, execErr := sql.Exec(`PRAGMA foreign_keys = ON;`); execErr != nil { + log.WithError(dbErr).Panicln("error enabling foreign keys") + } log.Debugln("Checking migrations status and running any required migrations...") @@ -78,6 +85,10 @@ func NewCContext() (*CContext, error) { log.WithError(statusErr).Panicln("error getting migrations status") } + if upErr := goose.Up(sql.DB, "./migrations"); upErr != nil { + log.WithError(upErr).Panicln("error migrating up") + } + api := models.NewAPICollection(theCtx, sql) // lineup := models.NewLineup() @@ -88,13 +99,29 @@ func NewCContext() (*CContext, error) { tuners := make(map[int]chan bool) + videoSources, videoSourcesErr := api.VideoSource.GetAllVideoSources(false) + if videoSourcesErr != nil { + log.WithError(videoSourcesErr).Panicln("error initializing video sources") + } + + videoSourceProvidersMap := make(map[int]video_providers.VideoProvider) + + for _, videoSource := range videoSources { + providerCfg := videoSource.ProviderConfiguration() + provider, providerErr := providerCfg.GetProvider() + if providerErr != nil { + log.WithError(providerErr).Panicln("error initializing provider") + } + videoSourceProvidersMap[videoSource.ID] = provider + } + context := &CContext{ - API: api, - Ctx: theCtx, - Log: log, - // Lineup: lineup, - Tuners: tuners, - RawSQL: sql, + API: api, + Ctx: theCtx, + Log: log, + Tuners: tuners, + VideoSourceProviders: videoSourceProvidersMap, + RawSQL: sql, } log.Debugln("Context: Context build complete") diff --git a/internal/providers/eternal.go b/internal/providers/eternal.go index 72bc1b6..d307eb4 100644 --- a/internal/providers/eternal.go +++ b/internal/providers/eternal.go @@ -1,4 +1,4 @@ package providers -// M3U:http://live.eternaltv.net:25461/get.php?username=xxxxxxx&password=xxxxxx&output=ts&type=m3uplus +// M3U: http://live.eternaltv.net:25461/get.php?username=xxxxxxx&password=xxxxxx&output=ts&type=m3uplus // XMLTV: http://live.eternaltv.net:25461/xmltv.php?username=xxxxx&password=xxxxx&type=m3uplus&output=ts diff --git a/internal/providers/main.go b/internal/providers/main.go index 41c199b..76e8b83 100644 --- a/internal/providers/main.go +++ b/internal/providers/main.go @@ -93,12 +93,3 @@ type Provider interface { RegexKey() string Configuration() Configuration } - -func contains(s []string, e string) bool { - for _, ss := range s { - if e == ss { - return true - } - } - return false -} diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go index 4344724..a4e85a8 100644 --- a/internal/providers/vaders.go +++ b/internal/providers/vaders.go @@ -11,6 +11,7 @@ import ( log "github.com/sirupsen/logrus" m3u "github.com/tellytv/telly/internal/m3uplus" "github.com/tellytv/telly/internal/xmltv" + "github.com/tellytv/telly/utils" ) // This regex matches and extracts the following URLs. @@ -111,7 +112,7 @@ func (v *vader) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) return nil, nil } - pChannel.Favorite = contains(v.BaseConfig.Favorites, track.Tags[favoriteTag]) + pChannel.Favorite = utils.Contains(v.BaseConfig.Favorites, track.Tags[favoriteTag]) return pChannel, nil } diff --git a/internal/video_providers/m3u.go b/internal/video_providers/m3u.go new file mode 100644 index 0000000..3a6cb12 --- /dev/null +++ b/internal/video_providers/m3u.go @@ -0,0 +1,135 @@ +package video_providers + +import ( + "fmt" + "strconv" + + "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/utils" +) + +type M3U struct { + BaseConfig Configuration + + Playlist *m3uplus.Playlist + channels map[int]Channel + categoriesStrCheck []string + categories []Category + seenFormats []string +} + +func newM3U(config *Configuration) (VideoProvider, error) { + m3u := &M3U{BaseConfig: *config} + + if loadErr := m3u.Refresh(); loadErr != nil { + return nil, loadErr + } + + return m3u, nil +} + +func (m *M3U) Name() string { + return "M3U" +} + +func (m *M3U) Categories() ([]Category, error) { + return m.categories, nil +} + +func (m *M3U) Formats() ([]string, error) { + return m.seenFormats, nil +} + +func (m *M3U) Channels() ([]Channel, error) { + outputChannels := make([]Channel, 0) + for _, channel := range m.channels { + outputChannels = append(outputChannels, channel) + } + return outputChannels, nil +} + +func (m *M3U) StreamURL(streamID int, wantedFormat string) (string, error) { + if val, ok := m.channels[streamID]; ok { + return val.streamUrl, nil + } + return "", fmt.Errorf("that channel id (%d) does not exist in the video source lineup", streamID) +} + +func (m *M3U) Refresh() error { + playlist, m3uErr := utils.GetM3U(m.BaseConfig.M3UURL, false) + if m3uErr != nil { + return fmt.Errorf("error when reading m3u: %s", m3uErr) + } + m.Playlist = playlist + + for _, track := range playlist.Tracks { + streamURL := streamNumberRegex(track.URI, -1)[0] + + channelID, channelIDErr := strconv.Atoi(streamURL[1]) + if channelIDErr != nil { + return fmt.Errorf("error when extracting channel id from m3u track: %s", channelIDErr) + } + + if !utils.Contains(m.seenFormats, streamURL[2]) { + m.seenFormats = append(m.seenFormats, streamURL[2]) + } + + nameVal := track.Name + + if val, ok := track.Tags["tvg-name"]; ok { + nameVal = val + } + + if m.BaseConfig.NameKey != "" { + if val, ok := track.Tags[m.BaseConfig.NameKey]; ok { + nameVal = val + } + } + + logoVal := track.Tags["tvg-logo"] + if m.BaseConfig.LogoKey != "" { + if val, ok := track.Tags[m.BaseConfig.LogoKey]; ok { + logoVal = val + } + } + + categoryVal := track.Tags["group-title"] + if m.BaseConfig.CategoryKey != "" { + if val, ok := track.Tags[m.BaseConfig.CategoryKey]; ok { + categoryVal = val + } + } + + if !utils.Contains(m.categoriesStrCheck, categoryVal) { + m.categoriesStrCheck = append(m.categoriesStrCheck, categoryVal) + m.categories = append(m.categories, Category{ + Name: categoryVal, + Type: "live", + }) + } + + epgIDVal := track.Tags["tvg-id"] + if m.BaseConfig.EPGIDKey != "" { + if val, ok := track.Tags[m.BaseConfig.EPGIDKey]; ok { + epgIDVal = val + } + } + + m.channels[channelID] = Channel{ + Name: nameVal, + StreamID: channelID, + Logo: logoVal, + Type: ChannelType(LiveStream), + Category: categoryVal, + EPGID: epgIDVal, + + streamUrl: track.URI, + } + } + + return nil +} + +func (m *M3U) Configuration() Configuration { + return m.BaseConfig +} diff --git a/internal/video_providers/main.go b/internal/video_providers/main.go new file mode 100644 index 0000000..c319fd3 --- /dev/null +++ b/internal/video_providers/main.go @@ -0,0 +1,88 @@ +package video_providers + +import ( + "regexp" + "strings" + "time" +) + +var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch +var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString +var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString +var hdRegex = regexp.MustCompile(`hd|4k`) + +type Configuration struct { + Name string `json:"-"` + Provider string + + // Only used for Xtream provider + Username string + Password string + BaseURL string + + // Only used for M3U provider + M3UURL string + NameKey string + LogoKey string + CategoryKey string + EPGIDKey string +} + +func (i *Configuration) GetProvider() (VideoProvider, error) { + switch strings.ToLower(i.Provider) { + case "xtream", "xstream": + return newXtreamCodes(i) + default: + return newM3U(i) + } +} + +type AccountInfo struct { + MaximumConnections int + ActiveConnections int + ExpirationDate time.Time + Status string +} + +// Category describes a grouping of streams. +type Category struct { + Name string `json:"name"` + Type string `json:"type"` +} + +// ChannelType is used for enumerating the ChannelType field in Channel. +type ChannelType string + +const ( + // LiveStream is the constant describing a live stream. + LiveStream ChannelType = "live" + // VODStream is the constant describing a video on demand stream. + VODStream = "vod" + // SeriesStream is the constant describing a TV series stream. + SeriesStream = "series" +) + +// Channel describes a channel available in the providers lineup with necessary pieces parsed into fields. +type Channel struct { + Name string + StreamID int + Logo string + Type ChannelType + Category string + EPGID string + + // Only needed for M3U provider + streamUrl string +} + +// VideoProvider describes a IPTV provider configuration. +type VideoProvider interface { + Name() string + Categories() ([]Category, error) + Formats() ([]string, error) + Channels() ([]Channel, error) + StreamURL(streamID int, wantedFormat string) (string, error) + + Refresh() error + Configuration() Configuration +} diff --git a/internal/video_providers/xtream.go b/internal/video_providers/xtream.go new file mode 100644 index 0000000..19e81c7 --- /dev/null +++ b/internal/video_providers/xtream.go @@ -0,0 +1,107 @@ +package video_providers + +import ( + "fmt" + + xc "github.com/tellytv/go.xtream-codes" +) + +type XtreamCodes struct { + BaseConfig Configuration + + client xc.XtreamClient + + categories map[int]xc.Category + streams map[int]xc.Stream + channels []Channel +} + +func newXtreamCodes(config *Configuration) (VideoProvider, error) { + xc := &XtreamCodes{BaseConfig: *config} + if loadErr := xc.Refresh(); loadErr != nil { + return nil, loadErr + } + return xc, nil +} + +func (x *XtreamCodes) Name() string { + return "Xtream Codes Server" +} + +func (x *XtreamCodes) Categories() ([]Category, error) { + outputCats := make([]Category, 0) + for _, cat := range x.categories { + outputCats = append(outputCats, Category{ + Name: cat.Name, + Type: cat.Type, + }) + } + return outputCats, nil +} + +func (x *XtreamCodes) Formats() ([]string, error) { + return x.client.UserInfo.AllowedOutputFormats, nil +} + +func (x *XtreamCodes) Channels() ([]Channel, error) { + return x.channels, nil +} + +func (x *XtreamCodes) StreamURL(streamID int, wantedFormat string) (string, error) { + return x.client.GetStreamURL(streamID, wantedFormat) +} + +func (x *XtreamCodes) Refresh() error { + client, clientErr := xc.NewClient(x.BaseConfig.Username, x.BaseConfig.Password, x.BaseConfig.BaseURL) + if clientErr != nil { + return fmt.Errorf("error creating xtream codes client: %s", clientErr) + } + x.client = *client + + if x.categories == nil { + x.categories = make(map[int]xc.Category) + } + + if x.streams == nil { + x.streams = make(map[int]xc.Stream) + } + + for _, xType := range []string{"live", "vod", "series"} { + cats, catsErr := x.client.GetCategories(xType) + if catsErr != nil { + return fmt.Errorf("error getting %s categories: %s", xType, catsErr) + } + for _, cat := range cats { + x.categories[cat.ID] = cat + } + + streams, streamsErr := x.client.GetStreams(xType, "") + if streamsErr != nil { + return fmt.Errorf("error getting %s streams: %s", xType, streamsErr) + } + for _, stream := range streams { + x.streams[stream.ID] = stream + } + } + + for _, stream := range x.streams { + categoryName := "" + if val, ok := x.categories[stream.CategoryID]; ok { + categoryName = val.Name + } + x.channels = append(x.channels, Channel{ + Name: stream.Name, + StreamID: stream.ID, + Logo: stream.Icon, + Type: ChannelType(stream.Type), + Category: categoryName, + EPGID: stream.EPGChannelID, + }) + } + + return nil +} + +func (x *XtreamCodes) Configuration() Configuration { + return x.BaseConfig +} diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql index cd95373..a53726b 100644 --- a/migrations/00001_init.sql +++ b/migrations/00001_init.sql @@ -7,6 +7,7 @@ CREATE TABLE IF NOT EXISTS video_source ( provider VARCHAR(64) NULL, username VARCHAR(64) NULL, password VARCHAR(64) NULL, + base_url TEXT, m3u_url TEXT, max_streams INTEGER, imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP @@ -16,10 +17,11 @@ CREATE TABLE IF NOT EXISTS video_source_track ( id INTEGER PRIMARY KEY AUTOINCREMENT, video_source_id INTEGER, name TEXT, - tags TEXT, - raw_line TEXT, - stream_url TEXT, - hd BOOLEAN, + stream_id INTEGER, + logo TEXT, + type TEXT, + category TEXT, + epg_id TEXT, imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, FOREIGN KEY(video_source_id) REFERENCES video_source(id) diff --git a/models/main.go b/models/main.go index 26136f4..62e0bc7 100644 --- a/models/main.go +++ b/models/main.go @@ -2,10 +2,7 @@ package models import ( "context" - "fmt" "os" - "regexp" - "strings" "github.com/jmoiron/sqlx" "github.com/sirupsen/logrus" @@ -20,23 +17,6 @@ var ( Hooks: make(logrus.LevelHooks), Level: logrus.DebugLevel, } - - safeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) - - stringSafer = func(input string) string { - ret := input - if strings.HasPrefix(input, "username=") { - ret = "username=REDACTED" - } else if strings.HasPrefix(input, "password=") { - ret = "password=REDACTED" - } else if strings.HasPrefix(input, "token=") { - ret = "token=bm90Zm9yeW91" // "notforyou" - } - if strings.HasSuffix(input, "&") { - return fmt.Sprintf("%s&", ret) - } - return ret - } ) // APICollection is a struct containing all models. diff --git a/models/old_lineup.go b/models/old_lineup.go index cecd9d1..ddd362f 100644 --- a/models/old_lineup.go +++ b/models/old_lineup.go @@ -1,12 +1,8 @@ package models import ( - "compress/gzip" "encoding/xml" "fmt" - "io" - "net/http" - "os" "regexp" "sort" "strconv" @@ -18,6 +14,7 @@ import ( m3u "github.com/tellytv/telly/internal/m3uplus" "github.com/tellytv/telly/internal/providers" "github.com/tellytv/telly/internal/xmltv" + "github.com/tellytv/telly/utils" ) // var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString @@ -211,22 +208,12 @@ func (l *Lineup) processProvider(provider providers.Provider) (int, error) { func (l *Lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { cacheFiles := provider.Configuration().CacheFiles - reader, m3uErr := GetM3U(provider.PlaylistURL(), cacheFiles) + rawPlaylist, m3uErr := utils.GetM3U(provider.PlaylistURL(), cacheFiles) if m3uErr != nil { log.WithError(m3uErr).Errorln("unable to get m3u file") return nil, nil, nil, m3uErr } - rawPlaylist, err := m3u.Decode(reader) - if err != nil { - log.WithError(err).Errorln("unable to parse m3u file") - return nil, nil, nil, err - } - - if closeM3UErr := reader.Close(); closeM3UErr != nil { - log.WithError(closeM3UErr).Panicln("error when closing m3u reader") - } - channelMap, programmeMap, epgErr := l.prepareEPG(provider, cacheFiles) if epgErr != nil { log.WithError(epgErr).Errorln("error when parsing EPG") @@ -267,7 +254,7 @@ func (l *Lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool } if v, ok := track.Tags[config.IncludeOnlyTag]; len(config.IncludeOnly) > 0 && ok { - return contains(config.IncludeOnly, v) + return utils.Contains(config.IncludeOnly, v) } filterRegex, regexErr := regexp.Compile(config.Filter) @@ -304,7 +291,7 @@ func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s epgProgrammeMap := make(map[string][]xmltv.Programme) if provider.EPGURL() != "" { var epgErr error - epg, epgErr = GetXMLTV(provider.EPGURL(), cacheFiles) + epg, epgErr = utils.GetXMLTV(provider.EPGURL(), cacheFiles) if epgErr != nil { return epgChannelMap, epgProgrammeMap, epgErr } @@ -370,7 +357,7 @@ func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s artworkMap := make(map[string][]schedulesdirect.ProgramArtwork) - chunks := chunkStringSlice(tmsIDs, 5000) + chunks := utils.ChunkStringSlice(tmsIDs, 5000) log.Infof("Making %d requests to Schedules Direct for program information, this might take a while", len(chunks)) @@ -394,7 +381,7 @@ func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s } } - chunks = chunkStringSlice(artworkTMSIDs, 500) + chunks = utils.ChunkStringSlice(artworkTMSIDs, 500) log.Infof("Making %d requests to Schedules Direct for artwork, this might take a while", len(chunks)) @@ -455,96 +442,6 @@ func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s return epgChannelMap, epgProgrammeMap, nil } -func GetM3U(path string, cacheFiles bool) (io.ReadCloser, error) { - safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) - log.Infof("Loading M3U from %s", safePath) - - file, _, err := GetFile(path, cacheFiles) - if err != nil { - return nil, err - } - - return file, nil -} - -func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { - safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) - log.Infof("Loading XMLTV from %s", safePath) - file, _, err := GetFile(path, cacheFiles) - if err != nil { - return nil, err - } - - decoder := xml.NewDecoder(file) - tvSetup := new(xmltv.TV) - if err := decoder.Decode(tvSetup); err != nil { - log.WithError(err).Errorln("Could not decode xmltv programme") - return nil, err - } - - if closeXMLErr := file.Close(); closeXMLErr != nil { - log.WithError(closeXMLErr).Panicln("error when closing xml reader") - } - - return tvSetup, nil -} - -func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { - transport := "disk" - - if strings.HasPrefix(strings.ToLower(path), "http") { - - transport = "http" - - req, reqErr := http.NewRequest("GET", path, nil) - if reqErr != nil { - return nil, transport, reqErr - } - - // For whatever reason, some providers only allow access from a "real" User-Agent. - req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36") - - resp, err := http.Get(path) - if err != nil { - return nil, transport, err - } - - if strings.HasSuffix(strings.ToLower(path), ".gz") || resp.Header.Get("Content-Type") == "application/x-gzip" { - log.Infof("File (%s) is gzipp'ed, ungzipping now, this might take a while", path) - gz, gzErr := gzip.NewReader(resp.Body) - if gzErr != nil { - return nil, transport, gzErr - } - - if cacheFiles { - return writeFile(path, transport, gz) - } - - return gz, transport, nil - } - - if cacheFiles { - return writeFile(path, transport, resp.Body) - } - - return resp.Body, transport, nil - } - - file, fileErr := os.Open(path) - if fileErr != nil { - return nil, transport, fileErr - } - - return file, transport, nil -} - -func writeFile(path, transport string, reader io.ReadCloser) (io.ReadCloser, string, error) { - // buf := new(bytes.Buffer) - // buf.ReadFrom(reader) - // buf.Bytes() - return reader, transport, nil -} - func containsIcon(s []xmltv.Icon, e string) bool { for _, ss := range s { if e == ss.Source { @@ -554,21 +451,6 @@ func containsIcon(s []xmltv.Icon, e string) bool { return false } -func chunkStringSlice(sl []string, chunkSize int) [][]string { - var divided [][]string - - for i := 0; i < len(sl); i += chunkSize { - end := i + chunkSize - - if end > len(sl) { - end = len(sl) - } - - divided = append(divided, sl[i:end]) - } - return divided -} - func MergeSchedulesDirectAndXMLTVProgramme(programme *xmltv.Programme, sdProgram schedulesdirect.ProgramInfo, artworks []schedulesdirect.ProgramArtwork) *xmltv.Programme { allTitles := make([]string, 0) @@ -859,12 +741,3 @@ func countDigits(i int) int { } return count } - -func contains(s []string, e string) bool { - for _, ss := range s { - if e == ss { - return true - } - } - return false -} diff --git a/models/video_source.go b/models/video_source.go index e3c2533..7f9133c 100644 --- a/models/video_source.go +++ b/models/video_source.go @@ -5,7 +5,7 @@ import ( "time" "github.com/jmoiron/sqlx" - "github.com/tellytv/telly/internal/providers" + "github.com/tellytv/telly/internal/video_providers" ) // VideoSourceDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -35,6 +35,7 @@ type VideoSource struct { Provider string `db:"provider"` Username string `db:"username"` Password string `db:"password"` + BaseURL string `db:"base_url"` M3UURL string `db:"m3u_url"` MaxStreams int `db:"max_streams"` ImportedAt *time.Time `db:"imported_at"` @@ -42,13 +43,14 @@ type VideoSource struct { Tracks []VideoSourceTrack `db:"tracks"` } -func (v *VideoSource) ProviderConfiguration() *providers.Configuration { - return &providers.Configuration{ +func (v *VideoSource) ProviderConfiguration() *video_providers.Configuration { + return &video_providers.Configuration{ Name: v.Name, Provider: v.Provider, Username: v.Username, Password: v.Password, - M3U: v.M3UURL, + BaseURL: v.BaseURL, + M3UURL: v.M3UURL, } } @@ -68,6 +70,7 @@ SELECT V.provider, V.username, V.password, + V.base_url, V.m3u_url, V.max_streams, V.imported_at @@ -77,8 +80,8 @@ SELECT func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) { videoSource := VideoSource{} res, err := db.SQL.NamedExec(` - INSERT INTO video_source (name, provider, username, password, m3u_url, max_streams) - VALUES (:name, :provider, :username, :password, :m3u_url, :max_streams);`, videoSourceStruct) + INSERT INTO video_source (name, provider, username, password, base_url, m3u_url, max_streams) + VALUES (:name, :provider, :username, :password, :base_url, :m3u_url, :max_streams);`, videoSourceStruct) if err != nil { return &videoSource, err } diff --git a/models/video_source_track.go b/models/video_source_track.go index a61c17e..16534ef 100644 --- a/models/video_source_track.go +++ b/models/video_source_track.go @@ -1,7 +1,6 @@ package models import ( - "encoding/json" "fmt" "time" @@ -30,14 +29,15 @@ func (db *VideoSourceTrackDB) tableName() string { } type VideoSourceTrack struct { - ID int `db:"id"` - VideoSourceID int `db:"video_source_id"` - Name string `db:"name"` - Tags json.RawMessage `db:"tags"` - RawLine string `db:"raw_line"` - StreamURL string `db:"stream_url"` - HighDefinition bool `db:"hd" json:"HD"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + VideoSourceID int `db:"video_source_id"` + Name string `db:"name"` + StreamID int `db:"stream_id"` + Logo string `db:"logo"` + Type string `db:"type"` + Category string `db:"category"` + EPGID string `db:"epg_id"` + ImportedAt *time.Time `db:"imported_at"` VideoSource *VideoSource VideoSourceName string @@ -57,10 +57,11 @@ SELECT T.id, T.video_source_id, T.name, - T.tags, - T.raw_line, - T.stream_url, - T.hd, + T.stream_id, + T.logo, + T.type, + T.category, + T.epg_id, T.imported_at FROM video_source_track T` @@ -68,8 +69,8 @@ SELECT func (db *VideoSourceTrackDB) InsertVideoSourceTrack(trackStruct VideoSourceTrack) (*VideoSourceTrack, error) { track := VideoSourceTrack{} res, err := db.SQL.NamedExec(` - INSERT INTO video_source_track (video_source_id, name, tags, raw_line, stream_url, hd) - VALUES (:video_source_id, :name, :tags, :raw_line, :stream_url, :hd);`, trackStruct) + INSERT INTO video_source_track (video_source_id, name, stream_id, logo, type, category, epg_id) + VALUES (:video_source_id, :name, :stream_id, :logo, :type, :category, :epg_id);`, trackStruct) if err != nil { return &track, err } diff --git a/utils/main.go b/utils/main.go index a88c30e..099036c 100644 --- a/utils/main.go +++ b/utils/main.go @@ -1,10 +1,38 @@ package utils import ( + "compress/gzip" + "encoding/xml" "fmt" + "io" "net" + "net/http" + "os" + "regexp" + "strings" "github.com/spf13/viper" + "github.com/tellytv/telly/internal/m3uplus" + "github.com/tellytv/telly/internal/xmltv" +) + +var ( + safeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) + + stringSafer = func(input string) string { + ret := input + if strings.HasPrefix(input, "username=") { + ret = "username=REDACTED" + } else if strings.HasPrefix(input, "password=") { + ret = "password=REDACTED" + } else if strings.HasPrefix(input, "token=") { + ret = "token=bm90Zm9yeW91" // "notforyou" + } + if strings.HasSuffix(input, "&") { + return fmt.Sprintf("%s&", ret) + } + return ret + } ) func GetTCPAddr(key string) *net.TCPAddr { @@ -14,3 +42,124 @@ func GetTCPAddr(key string) *net.TCPAddr { } return addr } + +func GetM3U(path string, cacheFiles bool) (*m3uplus.Playlist, error) { + // safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + + file, _, err := GetFile(path, cacheFiles) + if err != nil { + return nil, fmt.Errorf("error while opening m3u file: %s", err) + } + + rawPlaylist, decodeErr := m3uplus.Decode(file) + if decodeErr != nil { + return nil, fmt.Errorf("error while decoding m3u file: %s", decodeErr) + } + + if closeM3UErr := file.Close(); closeM3UErr != nil { + return nil, fmt.Errorf("error when closing m3u reader: %s", closeM3UErr) + } + + return rawPlaylist, nil +} + +func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { + // safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + + file, _, err := GetFile(path, cacheFiles) + if err != nil { + return nil, err + } + + decoder := xml.NewDecoder(file) + tvSetup := new(xmltv.TV) + if err := decoder.Decode(tvSetup); err != nil { + return nil, fmt.Errorf("could not decode xmltv programme: %s", err) + } + + if closeXMLErr := file.Close(); closeXMLErr != nil { + return nil, fmt.Errorf("error when closing xml reader", closeXMLErr) + } + + return tvSetup, nil +} + +func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { + transport := "disk" + + if strings.HasPrefix(strings.ToLower(path), "http") { + + transport = "http" + + req, reqErr := http.NewRequest("GET", path, nil) + if reqErr != nil { + return nil, transport, reqErr + } + + // For whatever reason, some providers only allow access from a "real" User-Agent. + req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36") + + resp, err := http.Get(path) + if err != nil { + return nil, transport, err + } + + if strings.HasSuffix(strings.ToLower(path), ".gz") || resp.Header.Get("Content-Type") == "application/x-gzip" { + // log.Infof("File (%s) is gzipp'ed, ungzipping now, this might take a while", path) + gz, gzErr := gzip.NewReader(resp.Body) + if gzErr != nil { + return nil, transport, gzErr + } + + if cacheFiles { + return writeFile(path, transport, gz) + } + + return gz, transport, nil + } + + if cacheFiles { + return writeFile(path, transport, resp.Body) + } + + return resp.Body, transport, nil + } + + file, fileErr := os.Open(path) + if fileErr != nil { + return nil, transport, fileErr + } + + return file, transport, nil +} + +func ChunkStringSlice(sl []string, chunkSize int) [][]string { + var divided [][]string + + for i := 0; i < len(sl); i += chunkSize { + end := i + chunkSize + + if end > len(sl) { + end = len(sl) + } + + divided = append(divided, sl[i:end]) + } + return divided +} + +func writeFile(path, transport string, reader io.ReadCloser) (io.ReadCloser, string, error) { + // buf := new(bytes.Buffer) + // buf.ReadFrom(reader) + // buf.Bytes() + return reader, transport, nil +} + +func Contains(s []string, e string) bool { + for _, ss := range s { + if e == ss { + return true + } + } + return false +} From 9120b4c309351bd2ebfb3d13f64e96a4caa4af18 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 25 Aug 2018 19:44:00 -0700 Subject: [PATCH 062/182] Update frontend --- api/a_api-packr.go | 2 +- frontend | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index 6aa38ba..e72a77a 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -11,7 +11,7 @@ func init() { packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/6RTXW/TMBR9768wfh2NRze2DMVBsK9uE3RDA6q9ec5N4+CP1PcmXfrrURs+tAlNIJ6Sc67P8T1X19mLImjqG2AVOZuPss2HWeUXkoPnGwJUkY8YyxyQYrpSEYEkb6kcp3xbIEMW8luwts/EADb0vUJgVYRScsF/O3jlQPLOwKoJkTjTwRN4knxlCqpkAZ3RMN6Cl8x4Q0bZMWplQb4abKzx31gEK7nRwXO2aV9y49QCxMN44IZ7S9VtYGJ0eNvJCc9Hj/VIvQWsAOinoiJq8I0QLUJSBk9qBRgcJDo4EcGCQkDRvU4mya7QiAKDNUWiETkznmARDfWSY6X20v3xyr87PrR+Z/5x9/NVoa+7y46WF9O9elbjUeOv/PJoOT9IL9y8m52vJ5ftWTg1x/VtWvd3N/PJmjMdA2KIZmG85MoH37vQ4tMx/H+MR2f+HGZ6777eTlV/1OCHdNmvT6+udRqK6f4Jztp1ATX5uDM7oxM30xdffLX4BDf753fvp4ftStflwTNhno0yMNuu8kwM25jdh6LfDkE1zTiGQHkmfv2OMtTRNPRjMQgeSNSqUwPLGUYteWw9GQdJvbUdSvnfCJtg+9JYi/8udcr4JyoxJMnE8Py+BwAA//+4MjUqjwMAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") diff --git a/frontend b/frontend index 017f5bf..d9a6003 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 017f5bf654b2ef925864db4ac11c97548693de53 +Subproject commit d9a6003a3c7e736b22cf3febe24182ca3008740c From 17f932a69632c0a82e325aa09287d7f6565ab03c Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 00:03:20 -0700 Subject: [PATCH 063/182] Guide providers and XMLTV tweaking, general cleanup and more --- api/guide_source.go | 24 +- api/tuner.go | 32 ++ api/video_source.go | 2 - api/xmltv.go | 25 +- context/context.go | 22 +- internal/guide_providers/main.go | 96 ++++ internal/guide_providers/schedules_direct.go | 535 +++++++++++++++++++ internal/guide_providers/xmltv.go | 85 +++ internal/xmltv/xmltv.go | 4 +- models/guide_source.go | 16 +- models/guide_source_channel.go | 5 +- models/guide_source_programme.go | 17 +- models/old_lineup.go | 40 +- utils/main.go | 116 ++++ 14 files changed, 944 insertions(+), 75 deletions(-) create mode 100644 internal/guide_providers/main.go create mode 100644 internal/guide_providers/schedules_direct.go create mode 100644 internal/guide_providers/xmltv.go diff --git a/api/guide_source.go b/api/guide_source.go index f3984da..d0c56a7 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -6,7 +6,6 @@ import ( "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" "github.com/tellytv/telly/models" - "github.com/tellytv/telly/utils" ) func addGuide(cc *context.CContext, c *gin.Context) { @@ -20,8 +19,6 @@ func addGuide(cc *context.CContext, c *gin.Context) { providerCfg := newGuide.ProviderConfiguration() - log.Infof("providerCfg %+v", providerCfg) - provider, providerErr := providerCfg.GetProvider() if providerErr != nil { c.AbortWithError(http.StatusInternalServerError, providerErr) @@ -30,14 +27,14 @@ func addGuide(cc *context.CContext, c *gin.Context) { log.Infoln("Detected passed config is for provider", provider.Name()) - xmlTV, xmlErr := utils.GetXMLTV(provider.EPGURL(), false) - if xmlErr != nil { - log.WithError(xmlErr).Errorln("unable to get XMLTV file") - c.AbortWithError(http.StatusBadRequest, xmlErr) + channels, channelsErr := provider.Channels() + if channelsErr != nil { + log.WithError(channelsErr).Errorln("unable to get channels from provider") + c.AbortWithError(http.StatusBadRequest, channelsErr) return } - for _, channel := range xmlTV.Channels { + for _, channel := range channels { newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(newGuide.ID, channel) if newChannelErr != nil { log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") @@ -46,16 +43,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { } newGuide.Channels = append(newGuide.Channels, *newChannel) } - // FIXME: Instead of importing _every_ programme when we add a new guide source, we should only import programmes for channels in a lineup. - // Otherwise, SQLite DB gets a lot bigger and harder to manage. - for _, programme := range xmlTV.Programmes { - _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(newGuide.ID, programme) - if programmeErr != nil { - log.WithError(programmeErr).Errorln("Error creating new guide source channel during programme import!") - c.AbortWithError(http.StatusInternalServerError, programmeErr) - return - } - } + c.JSON(http.StatusOK, newGuide) } } diff --git a/api/tuner.go b/api/tuner.go index 0174a2e..8f7ca1d 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -29,9 +29,41 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup return } + guideSources, guideSourceErr := cc.API.GuideSource.GetGuideSourcesForLineup(lineup.ID) + if guideSourceErr != nil { + log.WithError(guideSourceErr).Errorln("error getting guide sources for lineup") + return + } + + guideSourceUpdateMap := make(map[int][]string) + hdhrItems := make([]models.HDHomeRunLineupItem, 0) for _, channel := range channels { hdhrItems = append(hdhrItems, *channel.HDHR) + + guideSourceUpdateMap[channel.GuideChannel.GuideSource.ID] = append(guideSourceUpdateMap[channel.GuideChannel.GuideSource.ID], channel.GuideChannel.XMLTVID) + } + + for _, guideSource := range guideSources { + if channelsToGet, ok := guideSourceUpdateMap[guideSource.ID]; ok { + log.Infof("Beginning import of guide data from provider %s, getting channels %s", guideSource.Name, strings.Join(channelsToGet, ", ")) + schedule, scheduleErr := cc.GuideSourceProviders[guideSource.ID].Schedule(channelsToGet) + if scheduleErr != nil { + log.WithError(scheduleErr).Errorf("error when updating schedule for provider %s", guideSource.Name) + return + } + + for _, programme := range schedule { + _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(guideSource.ID, programme) + if programmeErr != nil { + log.WithError(programmeErr).Errorln("error while inserting programmes") + return + } + } + + log.Infof("Completed import of %d programs", len(schedule)) + + } } metrics.ExposedChannels.WithLabelValues(lineup.Name).Set(float64(len(channels))) diff --git a/api/video_source.go b/api/video_source.go index caaca9e..ca5093d 100644 --- a/api/video_source.go +++ b/api/video_source.go @@ -29,8 +29,6 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { providerCfg := newProvider.ProviderConfiguration() - log.Infof("providerCfg %+v", providerCfg) - provider, providerErr := providerCfg.GetProvider() if providerErr != nil { log.WithError(providerErr).Errorln("error getting provider") diff --git a/api/xmltv.go b/api/xmltv.go index fbf728e..aa8f912 100644 --- a/api/xmltv.go +++ b/api/xmltv.go @@ -1,19 +1,22 @@ package api import ( + "encoding/json" "encoding/xml" "fmt" "net/http" - "sort" "strconv" + "time" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/guide_providers" "github.com/tellytv/telly/internal/xmltv" ) func xmlTV(cc *context.CContext, c *gin.Context) { epg := &xmltv.TV{ + Date: time.Now().Format("2006-01-02"), GeneratorInfoName: "telly", GeneratorInfoURL: "https://github.com/tellytv/telly", } @@ -35,9 +38,23 @@ func xmlTV(cc *context.CContext, c *gin.Context) { for _, lineup := range lineups { for _, channel := range lineup.Channels { epgMatchMap[channel.GuideChannel.XMLTVID] = channel.ID + + var guideChannel guide_providers.Channel + + if jsonErr := json.Unmarshal(channel.GuideChannel.Data, &guideChannel); jsonErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while unmarshalling lineupchannel to guide_providers.channel: %s", jsonErr)) + return + } + + xChannel := guideChannel.XMLTV() + + displayNames := []xmltv.CommonElement{xmltv.CommonElement{Value: channel.Title}} + displayNames = append(displayNames, xChannel.DisplayNames...) + epg.Channels = append(epg.Channels, xmltv.Channel{ ID: strconv.Itoa(channel.ID), - DisplayNames: []xmltv.CommonElement{xmltv.CommonElement{Value: channel.Title}}, + DisplayNames: displayNames, + Icons: xChannel.Icons, LCN: channel.ChannelNumber, }) } @@ -48,10 +65,6 @@ func xmlTV(cc *context.CContext, c *gin.Context) { epg.Programmes = append(epg.Programmes, *programme.XMLTV) } - sort.Slice(epg.Channels, func(i, j int) bool { - return epg.Channels[i].LCN < epg.Channels[j].LCN - }) - buf, marshallErr := xml.MarshalIndent(epg, "", "\t") if marshallErr != nil { c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error marshalling EPG to XML")) diff --git a/context/context.go b/context/context.go index 67a7296..3818f5e 100644 --- a/context/context.go +++ b/context/context.go @@ -10,6 +10,7 @@ import ( "github.com/pressly/goose" "github.com/sirupsen/logrus" "github.com/spf13/viper" + "github.com/tellytv/telly/internal/guide_providers" "github.com/tellytv/telly/internal/video_providers" "github.com/tellytv/telly/models" ) @@ -21,7 +22,7 @@ type CContext struct { Lineup *models.Lineup Log *logrus.Logger Tuners map[int]chan bool - GuideSources map[int]models.GuideSource + GuideSourceProviders map[int]guide_providers.GuideProvider VideoSourceProviders map[int]video_providers.VideoProvider RawSQL *sqlx.DB @@ -35,7 +36,7 @@ func (cc *CContext) Copy() *CContext { Lineup: cc.Lineup, Log: cc.Log, Tuners: cc.Tuners, - GuideSources: cc.GuideSources, + GuideSourceProviders: cc.GuideSourceProviders, VideoSourceProviders: cc.VideoSourceProviders, RawSQL: cc.RawSQL, } @@ -99,6 +100,22 @@ func NewCContext() (*CContext, error) { tuners := make(map[int]chan bool) + guideSources, guideSourcesErr := api.GuideSource.GetAllGuideSources(false) + if guideSourcesErr != nil { + log.WithError(guideSourcesErr).Panicln("error initializing video sources") + } + + guideSourceProvidersMap := make(map[int]guide_providers.GuideProvider) + + for _, guideSource := range guideSources { + providerCfg := guideSource.ProviderConfiguration() + provider, providerErr := providerCfg.GetProvider() + if providerErr != nil { + log.WithError(providerErr).Panicln("error initializing provider") + } + guideSourceProvidersMap[guideSource.ID] = provider + } + videoSources, videoSourcesErr := api.VideoSource.GetAllVideoSources(false) if videoSourcesErr != nil { log.WithError(videoSourcesErr).Panicln("error initializing video sources") @@ -120,6 +137,7 @@ func NewCContext() (*CContext, error) { Ctx: theCtx, Log: log, Tuners: tuners, + GuideSourceProviders: guideSourceProvidersMap, VideoSourceProviders: videoSourceProvidersMap, RawSQL: sql, } diff --git a/internal/guide_providers/main.go b/internal/guide_providers/main.go new file mode 100644 index 0000000..c325b8d --- /dev/null +++ b/internal/guide_providers/main.go @@ -0,0 +1,96 @@ +// Package guide_providers is a telly internal package to provide electronic program guide (EPG) data. +// It is generally modeled after the XMLTV standard with slight deviations to accomodate other providers. +package guide_providers + +import ( + "strings" + + "github.com/tellytv/telly/internal/xmltv" +) + +type Configuration struct { + Name string `json:"-"` + Provider string + + // Only used for Schedules Direct provider + Username string + Password string + Lineups []string + + // Only used for XMLTV provider + XMLTVURL string +} + +func (i *Configuration) GetProvider() (GuideProvider, error) { + switch strings.ToLower(i.Provider) { + case "schedulesdirect", "schedules-direct", "sd": + return newSchedulesDirect(i) + default: + return newXMLTV(i) + } +} + +// Channel describes a channel available in the providers lineup with necessary pieces parsed into fields. +type Channel struct { + // Required Fields + ID string + Name string + Logos []Logo + Number string + + // Optional fields + CallSign string + URLs []string + Lineup string +} + +func (c *Channel) XMLTV() xmltv.Channel { + ch := xmltv.Channel{ + ID: c.ID, + LCN: c.Number, + URLs: c.URLs, + } + + // Why do we do this? From tv_grab_zz_sdjson: + // + // MythTV seems to assume that the first three display-name elements are + // name, callsign and channel number. We follow that scheme here. + ch.DisplayNames = []xmltv.CommonElement{ + xmltv.CommonElement{ + Value: c.Name, + }, + xmltv.CommonElement{ + Value: c.CallSign, + }, + xmltv.CommonElement{ + Value: c.Number, + }, + } + + for _, logo := range c.Logos { + ch.Icons = append(ch.Icons, xmltv.Icon{ + Source: logo.URL, + Width: logo.Width, + Height: logo.Height, + }) + } + + return ch +} + +// A Logo stores the information about a channel logo +type Logo struct { + URL string `json:"URL"` + Height int `json:"height"` + Width int `json:"width"` +} + +// GuideProvider describes a IPTV provider configuration. +type GuideProvider interface { + Name() string + Channels() ([]Channel, error) + Schedule(channelIDs []string) ([]xmltv.Programme, error) + + Refresh() error + Configuration() Configuration +} diff --git a/internal/guide_providers/schedules_direct.go b/internal/guide_providers/schedules_direct.go new file mode 100644 index 0000000..fac89af --- /dev/null +++ b/internal/guide_providers/schedules_direct.go @@ -0,0 +1,535 @@ +package guide_providers + +import ( + "fmt" + "strconv" + "strings" + "time" + + "github.com/tellytv/go.schedulesdirect" + "github.com/tellytv/telly/internal/xmltv" + "github.com/tellytv/telly/utils" +) + +type SchedulesDirect struct { + BaseConfig Configuration + + client *schedulesdirect.Client + channels []Channel + stations map[string]sdStationContainer +} + +func newSchedulesDirect(config *Configuration) (GuideProvider, error) { + provider := &SchedulesDirect{BaseConfig: *config} + + if loadErr := provider.Refresh(); loadErr != nil { + return nil, fmt.Errorf("error when refreshing provider data: %s", loadErr) + } + + return provider, nil +} + +func (s *SchedulesDirect) Name() string { + return "Schedules Direct" +} + +func (s *SchedulesDirect) Channels() ([]Channel, error) { + return s.channels, nil +} + +func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, error) { + // First, convert the string slice of channelIDs into a slice of schedule requests. + reqs := make([]schedulesdirect.StationScheduleRequest, 0) + for _, channelID := range channelIDs { + splitID := strings.Split(channelID, ".")[1] + reqs = append(reqs, schedulesdirect.StationScheduleRequest{ + StationID: splitID, + Dates: []string{time.Now().Format("2006-01-02"), time.Now().AddDate(0, 0, 7).Format("2006-01-02")}, + }) + } + + // Next, get the results + schedules, schedulesErr := s.client.GetSchedules(reqs) + if schedulesErr != nil { + return nil, fmt.Errorf("error getting schedules from schedules direct: %s", schedulesErr) + } + + // Then, we need to bundle up all the program IDs and request detailed information about them. + neededProgramIDs := make(map[string]struct{}, 0) + + for _, schedule := range schedules { + for _, program := range schedule.Programs { + neededProgramIDs[program.ProgramID] = struct{}{} + } + } + + extendedProgramInfo := make(map[string]sdProgramContainer, 0) + + programsWithArtwork := make(map[string]struct{}, 0) + + // IDs slice is built, let's chunk and get the info. + for _, chunk := range utils.ChunkStringSlice(utils.GetStringMapKeys(neededProgramIDs), 5000) { + moreInfo, moreInfoErr := s.client.GetProgramInfo(chunk) + if moreInfoErr != nil { + return nil, fmt.Errorf("error when getting more program details from schedules direct: %s", moreInfoErr) + } + + for _, program := range moreInfo { + extendedProgramInfo[program.ProgramID] = sdProgramContainer{ + Info: program, + } + if program.HasArtwork() { + programsWithArtwork[program.ProgramID] = struct{}{} + } + } + } + + allArtwork := make(map[string][]schedulesdirect.ProgramArtwork, 0) + + // Now that we have the initial program info results, let's get all the artwork. + for _, chunk := range utils.ChunkStringSlice(utils.GetStringMapKeys(programsWithArtwork), 500) { + artworkResp, artworkErr := s.client.GetArtworkForProgramIDs(chunk) + if artworkErr != nil { + return nil, fmt.Errorf("error when getting artwork from schedules direct: %s", artworkErr) + } + + for _, artworks := range artworkResp { + allArtwork[artworks.ProgramID] = *artworks.Artwork + } + } + + // We finally have all the data, time to convert to the XMLTV format. + programmes := make([]xmltv.Programme, 0) + + // Iterate over every result, converting to XMLTV format. + for _, schedule := range schedules { + station := s.stations[schedule.StationID] + + for _, airing := range schedule.Programs { + programInfo := extendedProgramInfo[airing.ProgramID] + endTime := airing.AirDateTime.Add(time.Duration(airing.Duration) * time.Second) + length := xmltv.Length{Units: "seconds", Value: strconv.Itoa(airing.Duration)} + + // First we fill in all the "simple" fields that don't require any extra processing. + xmlProgramme := xmltv.Programme{ + Channel: fmt.Sprintf("I%s.%s.schedulesdirect.org", station.ChannelMap.Channel, station.Station.StationID), + ID: airing.ProgramID, + Languages: []xmltv.CommonElement{xmltv.CommonElement{ + Value: station.Station.BroadcastLanguage[0], + Lang: station.Station.BroadcastLanguage[0], + }}, + Length: &length, + Start: &xmltv.Time{airing.AirDateTime}, + Stop: &xmltv.Time{endTime}, + } + + // Now for the fields that have to be parsed. + xmlProgramme.Titles = make([]xmltv.CommonElement, 0) + for _, sdTitle := range programInfo.Info.Titles { + xmlProgramme.Titles = append(xmlProgramme.Titles, xmltv.CommonElement{ + Value: sdTitle.Title120, + }) + } + + if programInfo.Info.EpisodeTitle150 != "" { + xmlProgramme.SecondaryTitles = []xmltv.CommonElement{xmltv.CommonElement{ + Value: programInfo.Info.EpisodeTitle150, + }} + } + + xmlProgramme.Descriptions = make([]xmltv.CommonElement, 0) + for _, sdDescription := range programInfo.Info.GetOrderedDescriptions() { + xmlProgramme.Descriptions = append(xmlProgramme.Descriptions, xmltv.CommonElement{ + Value: sdDescription.Description, + Lang: sdDescription.Language, + }) + } + + for _, sdCast := range append(programInfo.Info.Cast, programInfo.Info.Crew...) { + if xmlProgramme.Credits == nil { + xmlProgramme.Credits = &xmltv.Credits{} + } + lowerRole := strings.ToLower(sdCast.Role) + if strings.Contains(lowerRole, "director") { + xmlProgramme.Credits.Directors = append(xmlProgramme.Credits.Directors, sdCast.Name) + } else if strings.Contains(lowerRole, "actor") || strings.Contains(lowerRole, "voice") { + role := "" + if sdCast.Role != "Actor" { + role = sdCast.Role + } + xmlProgramme.Credits.Actors = append(xmlProgramme.Credits.Actors, xmltv.Actor{ + Role: role, + Value: sdCast.Name, + }) + } else if strings.Contains(lowerRole, "writer") { + xmlProgramme.Credits.Writers = append(xmlProgramme.Credits.Writers, sdCast.Name) + } else if strings.Contains(lowerRole, "producer") { + xmlProgramme.Credits.Producers = append(xmlProgramme.Credits.Producers, sdCast.Name) + } else if strings.Contains(lowerRole, "host") || strings.Contains(lowerRole, "anchor") { + xmlProgramme.Credits.Presenters = append(xmlProgramme.Credits.Presenters, sdCast.Name) + } else if strings.Contains(lowerRole, "guest") || strings.Contains(lowerRole, "contestant") { + xmlProgramme.Credits.Guests = append(xmlProgramme.Credits.Guests, sdCast.Name) + } + } + + if programInfo.Info.Movie.Year != "" { + yearInt, yearIntErr := strconv.Atoi(programInfo.Info.Movie.Year) + if yearIntErr == nil { // Date isn't that important of a field, if we hit an error while parsing just don't add date. + xmlProgramme.Date = xmltv.Date(time.Date(yearInt, 1, 1, 1, 1, 1, 1, time.UTC)) + } + } + + xmlProgramme.Categories = make([]xmltv.CommonElement, 0) + seenCategories := make(map[string]struct{}) + for _, sdCategory := range programInfo.Info.Genres { + if _, ok := seenCategories[sdCategory]; !ok { + xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ + Value: sdCategory, + }) + seenCategories[sdCategory] = struct{}{} + } + } + + entityTypeCat := programInfo.Info.EntityType + + if programInfo.Info.EntityType == "episode" { + entityTypeCat = "series" + } + + if _, ok := seenCategories[entityTypeCat]; !ok { + xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ + Value: entityTypeCat, + }) + } + + seenKeywords := make(map[string]struct{}) + for _, keywords := range programInfo.Info.Keywords { + for _, keyword := range keywords { + if _, ok := seenKeywords[keyword]; !ok { + xmlProgramme.Keywords = append(xmlProgramme.Keywords, xmltv.CommonElement{ + Value: utils.KebabCase(keyword), + }) + seenKeywords[keyword] = struct{}{} + } + } + } + + if programInfo.Info.OfficialURL != "" { + xmlProgramme.URLs = []string{programInfo.Info.OfficialURL} + } + + if artworks, ok := allArtwork[programInfo.Info.ProgramID[:10]]; ok { + for _, artworkItem := range artworks { + if strings.HasPrefix(artworkItem.URI, "assets/") { + artworkItem.URI = fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", artworkItem.URI) + } + xmlProgramme.Icons = append(xmlProgramme.Icons, xmltv.Icon{ + Source: artworkItem.URI, + Width: artworkItem.Width, + Height: artworkItem.Height, + }) + } + } + + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ + System: "dd_progid", + Value: programInfo.Info.ProgramID, + }) + + xmltvns := getXMLTVNumber(programInfo.Info.Metadata, airing.ProgramPart) + if xmltvns != "" { + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmltvns}) + } + + sxxexx := "" + + for _, metadata := range programInfo.Info.Metadata { + for _, mdProvider := range metadata { + if mdProvider.Season > 0 && mdProvider.Episode > 0 { + sxxexx = fmt.Sprintf("S%sE%s", utils.PadNumberWithZeros(mdProvider.Season, 2), utils.PadNumberWithZeros(mdProvider.Episode, 2)) + } + } + } + + if sxxexx != "" { + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "SxxExx", Value: sxxexx}) + } + + for _, videoProperty := range airing.VideoProperties { + if xmlProgramme.Video == nil { + xmlProgramme.Video = &xmltv.Video{} + } + if station.Station.IsRadioStation { + continue + } + xmlProgramme.Video.Present = "yes" + if strings.ToLower(videoProperty) == "hdtv" { + xmlProgramme.Video.Quality = "HDTV" + xmlProgramme.Video.Aspect = "16:9" + } else if strings.ToLower(videoProperty) == "uhdtv" { + xmlProgramme.Video.Quality = "UHD" + } else if strings.ToLower(videoProperty) == "sdtv" { + xmlProgramme.Video.Aspect = "4:3" + } + } + + for _, audioProperty := range airing.AudioProperties { + switch strings.ToLower(audioProperty) { + case "dd": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "dolby digital"} + case "dd 5.1", "surround", "atmos": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "surround"} + case "dolby": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "dolby"} + case "stereo": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "stereo"} + case "mono": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "mono"} + case "cc", "subtitled": + xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "teletext"}) + } + } + + if airing.Signed { + xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "deaf-signed"}) + } + + if !time.Time(programInfo.Info.OriginalAirDate).IsZero() { + if !airing.New { + xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ + Start: xmltv.Time{time.Time(programInfo.Info.OriginalAirDate)}, + } + } + timeToUse := time.Time(programInfo.Info.OriginalAirDate) + if airing.New { + timeToUse = airing.AirDateTime + } + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ + System: "original-air-date", + Value: timeToUse.Format("2006-01-02 15:04:05"), + }) + } + + if airing.Repeat && xmlProgramme.PreviouslyShown != nil { + xmlProgramme.PreviouslyShown = nil + } + + seenRatings := make(map[string]string) + for _, rating := range append(programInfo.Info.ContentRating, airing.Ratings...) { + if _, ok := seenRatings[rating.Body]; !ok { + xmlProgramme.Ratings = append(xmlProgramme.Ratings, xmltv.Rating{ + Value: rating.Code, + System: rating.Body, + }) + seenRatings[rating.Body] = rating.Code + } + } + + for _, starRating := range programInfo.Info.Movie.QualityRating { + xmlProgramme.Ratings = append(xmlProgramme.Ratings, xmltv.Rating{ + Value: fmt.Sprintf("%s/%s", starRating.Rating, starRating.MaxRating), + System: starRating.RatingsBody, + }) + } + + if airing.IsPremiereOrFinale != "" { + xmlProgramme.Premiere = &xmltv.CommonElement{ + Lang: "en", + Value: string(airing.IsPremiereOrFinale), + } + } + + if airing.Premiere { + xmlProgramme.Premiere = &xmltv.CommonElement{} + } + + if airing.New { + elm := xmltv.ElementPresent(true) + xmlProgramme.New = &elm + } + + // Done processing! + programmes = append(programmes, xmlProgramme) + + } + } + + return programmes, nil +} + +func (s *SchedulesDirect) Refresh() error { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } + + // First, get the lineups added to the users account. + // SD API docs say to check system status before proceeding. + // NewClient above does that automatically for us. + status, statusErr := s.client.GetStatus() + if statusErr != nil { + return fmt.Errorf("error getting schedules direct status: %s", statusErr) + } + + allLineups := make([]string, 0) + + for _, lineup := range status.Lineups { + allLineups = append(allLineups, lineup.Lineup) + } + + // Figure out if we need to add any lineups to the account. + neededLineups := make([]string, 0) + + for _, wantedLineup := range s.BaseConfig.Lineups { + needLineup := true + for _, previouslyAddedLineup := range allLineups { + if previouslyAddedLineup == wantedLineup { + needLineup = false + allLineups = append(allLineups, previouslyAddedLineup) + } + } + if needLineup { + neededLineups = append(neededLineups, wantedLineup) + } + } + + // Sanity check + if len(status.Lineups) == status.Account.MaxLineups && len(neededLineups) > 0 { + return fmt.Errorf("attempting to add more than %d lineups to a schedules direct account will fail, exiting prematurely", status.Account.MaxLineups) + } + + // Add needed lineups + for _, neededLineupName := range neededLineups { + if _, err := s.client.AddLineup(neededLineupName); err != nil { + return fmt.Errorf("error when adding lineup %s to schedules direct account: %s", neededLineupName, err) + } + allLineups = append(allLineups, neededLineupName) + } + + // Next, let's fill in the available channels in all the lineups. + for _, lineupName := range allLineups { + channels, channelsErr := s.client.GetChannels(lineupName, true) + if channelsErr != nil { + return fmt.Errorf("error getting channels from schedules direct for lineup %s: %s", lineupName, channelsErr) + } + + stationsMap := make(map[string]sdStationContainer) + + for _, stn := range channels.Stations { + stationsMap[stn.StationID] = sdStationContainer{Station: stn} + } + + for _, entry := range channels.Map { + if val, ok := stationsMap[entry.StationID]; ok { + val.ChannelMap = entry + stationsMap[entry.StationID] = val + } + } + + s.stations = make(map[string]sdStationContainer) + + if s.channels == nil { + s.channels = make([]Channel, 0) + } + + for _, station := range stationsMap { + logos := make([]Logo, 0) + + for _, stnLogo := range station.Station.Logos { + logos = append(logos, Logo{ + URL: stnLogo.URL, + Height: stnLogo.Height, + Width: stnLogo.Width, + }) + } + + s.channels = append(s.channels, Channel{ + ID: fmt.Sprintf("I%s.%s.schedulesdirect.org", station.ChannelMap.Channel, station.Station.StationID), + Name: station.Station.Name, + Logos: logos, + Number: station.ChannelMap.Channel, + CallSign: station.Station.CallSign, + Lineup: lineupName, + }) + + s.stations[station.Station.StationID] = station + } + } + + // We're done! + + return nil +} + +func (s *SchedulesDirect) Configuration() Configuration { + return s.BaseConfig +} + +type sdStationContainer struct { + Station schedulesdirect.Station + ChannelMap schedulesdirect.ChannelMap +} + +type sdProgramContainer struct { + Info schedulesdirect.ProgramInfo + Artwork []schedulesdirect.ProgramArtwork +} + +func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo schedulesdirect.Part) string { + seasonNumber := 0 + episodeNumber := 0 + totalSeasons := 0 + totalEpisodes := 0 + numbersFilled := false + + for _, meta := range mdata { + for _, metadata := range meta { + if metadata.Season > 0 { + seasonNumber = metadata.Season - 1 // SD metadata isnt 0 index + numbersFilled = true + } + if metadata.Episode > 0 { + episodeNumber = metadata.Episode - 1 + numbersFilled = true + } + if metadata.TotalEpisodes > 0 { + totalEpisodes = metadata.TotalEpisodes + numbersFilled = true + } + if metadata.TotalSeasons > 0 { + totalSeasons = metadata.TotalSeasons + numbersFilled = true + } + } + } + + if numbersFilled { + seasonNumberStr := fmt.Sprintf("%d", seasonNumber) + if totalSeasons > 0 { + seasonNumberStr = fmt.Sprintf("%d/%d", seasonNumber, totalSeasons) + } + episodeNumberStr := fmt.Sprintf("%d", episodeNumber) + if totalEpisodes > 0 { + episodeNumberStr = fmt.Sprintf("%d/%d", episodeNumber, totalEpisodes) + } + + partNumber := multipartInfo.PartNumber + totalParts := multipartInfo.TotalParts + + partStr := "0" + if partNumber > 0 { + partStr = fmt.Sprintf("%d", partNumber) + if totalParts > 0 { + partStr = fmt.Sprintf("%d/%d", partNumber, totalParts) + } + } + + return fmt.Sprintf("%s.%s.%s", seasonNumberStr, episodeNumberStr, partStr) + } + + return "" +} diff --git a/internal/guide_providers/xmltv.go b/internal/guide_providers/xmltv.go new file mode 100644 index 0000000..1b0ffcb --- /dev/null +++ b/internal/guide_providers/xmltv.go @@ -0,0 +1,85 @@ +package guide_providers + +import ( + "fmt" + + "github.com/tellytv/telly/internal/xmltv" + "github.com/tellytv/telly/utils" +) + +type XMLTV struct { + BaseConfig Configuration + + channels []Channel + file *xmltv.TV +} + +func newXMLTV(config *Configuration) (GuideProvider, error) { + provider := &XMLTV{BaseConfig: *config} + + if loadErr := provider.Refresh(); loadErr != nil { + return nil, loadErr + } + + return provider, nil +} + +func (x *XMLTV) Name() string { + return "XMLTV" +} + +func (x *XMLTV) Channels() ([]Channel, error) { + return x.channels, nil +} + +func (x *XMLTV) Schedule(channelIDs []string) ([]xmltv.Programme, error) { + channelIDMap := make(map[string]struct{}) + for _, chanID := range channelIDs { + channelIDMap[chanID] = struct{}{} + } + + filteredProgrammes := make([]xmltv.Programme, 0) + + for _, programme := range x.file.Programmes { + if _, ok := channelIDMap[programme.Channel]; ok { + filteredProgrammes = append(filteredProgrammes, programme) + } + } + + return filteredProgrammes, nil +} + +func (x *XMLTV) Refresh() error { + xTV, xTVErr := utils.GetXMLTV(x.BaseConfig.XMLTVURL, false) + if xTVErr != nil { + return fmt.Errorf("error when getting XMLTV file: %s", xTVErr) + } + + x.file = xTV + + for _, channel := range xTV.Channels { + logos := make([]Logo, 0) + + for _, icon := range channel.Icons { + logos = append(logos, Logo{ + URL: icon.Source, + Height: icon.Height, + Width: icon.Width, + }) + } + + x.channels = append(x.channels, Channel{ + ID: channel.ID, + Name: channel.DisplayNames[0].Value, + Logos: logos, + Number: channel.LCN, + CallSign: "UNK", + }) + } + + return nil +} + +func (x *XMLTV) Configuration() Configuration { + return x.BaseConfig +} diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 541faf4..d64d7f5 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -110,6 +110,7 @@ func (t *TV) LoadXML(f *os.File) error { // Channel details of a channel type Channel struct { + XMLName xml.Name `xml:"channel" json:"-" db:"-"` DisplayNames []CommonElement `xml:"display-name" json:"displayNames" db:"display_names"` Icons []Icon `xml:"icon,omitempty" json:"icons,omitempty" db:"icons,omitempty"` URLs []string `xml:"url,omitempty" json:"urls,omitempty" db:"urls,omitempty"` @@ -119,6 +120,7 @@ type Channel struct { // Programme details of a single programme transmission type Programme struct { + XMLName xml.Name `xml:"programme" json:"-" db:"-"` ID string `xml:"id,attr,omitempty" json:"id,omitempty" db:"id,omitempty"` // not defined by standard, but often present Titles []CommonElement `xml:"title" json:"titles" db:"titles"` SecondaryTitles []CommonElement `xml:"sub-title,omitempty" json:"secondaryTitles,omitempty" db:"secondary_titles,omitempty"` @@ -236,7 +238,7 @@ type Audio struct { // PreviouslyShown When and where the programme was last shown, if known. type PreviouslyShown struct { - Start string `xml:"start,attr,omitempty" json:"start,omitempty" db:"start,omitempty"` + Start Time `xml:"start,attr,omitempty" json:"start,omitempty" db:"start,omitempty"` Channel string `xml:"channel,attr,omitempty" json:"channel,omitempty" db:"channel,omitempty"` } diff --git a/models/guide_source.go b/models/guide_source.go index e8b3b6d..acb4693 100644 --- a/models/guide_source.go +++ b/models/guide_source.go @@ -5,7 +5,7 @@ import ( "time" "github.com/jmoiron/sqlx" - "github.com/tellytv/telly/internal/providers" + "github.com/tellytv/telly/internal/guide_providers" ) // GuideSourceDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -41,13 +41,13 @@ type GuideSource struct { Channels []GuideSourceChannel `db:"-"` } -func (g *GuideSource) ProviderConfiguration() *providers.Configuration { - return &providers.Configuration{ +func (g *GuideSource) ProviderConfiguration() *guide_providers.Configuration { + return &guide_providers.Configuration{ Name: g.Name, Provider: g.Provider, Username: g.Username, Password: g.Password, - EPG: g.URL, + XMLTVURL: g.URL, } } @@ -58,6 +58,7 @@ type GuideSourceAPI interface { UpdateGuideSource(guideSourceID int, description string) (*GuideSource, error) GetGuideSourceByID(id int) (*GuideSource, error) GetAllGuideSources(includeChannels bool) ([]GuideSource, error) + GetGuideSourcesForLineup(lineupID int) ([]GuideSource, error) } const baseGuideSourceQuery string = ` @@ -127,3 +128,10 @@ func (db *GuideSourceDB) GetAllGuideSources(includeChannels bool) ([]GuideSource } return sources, err } + +// GetGuideSourcesForLineup returns a slice of GuideSource for the given lineup ID. +func (db *GuideSourceDB) GetGuideSourcesForLineup(lineupID int) ([]GuideSource, error) { + providers := make([]GuideSource, 0) + err := db.SQL.Select(&providers, `SELECT * FROM guide_source WHERE id IN (SELECT guide_id FROM guide_source_channel WHERE id IN (SELECT id FROM lineup_channel WHERE lineup_id = $1))`, lineupID) + return providers, err +} diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index 156fdbc..ee45ac4 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -6,6 +6,7 @@ import ( "time" "github.com/jmoiron/sqlx" + "github.com/tellytv/telly/internal/guide_providers" "github.com/tellytv/telly/internal/xmltv" ) @@ -44,7 +45,7 @@ type GuideSourceChannel struct { // GuideSourceChannelAPI contains all methods for the User struct type GuideSourceChannelAPI interface { - InsertGuideSourceChannel(guideID int, channel xmltv.Channel) (*GuideSourceChannel, error) + InsertGuideSourceChannel(guideID int, channel guide_providers.Channel) (*GuideSourceChannel, error) DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) @@ -61,7 +62,7 @@ SELECT FROM guide_source_channel G` // InsertGuideSourceChannel inserts a new GuideSourceChannel into the database. -func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel xmltv.Channel) (*GuideSourceChannel, error) { +func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel guide_providers.Channel) (*GuideSourceChannel, error) { marshalled, marshalErr := json.Marshal(channel) if marshalErr != nil { return nil, marshalErr diff --git a/models/guide_source_programme.go b/models/guide_source_programme.go index 0a8b4e2..f0430ab 100644 --- a/models/guide_source_programme.go +++ b/models/guide_source_programme.go @@ -69,8 +69,9 @@ SELECT func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, programme xmltv.Programme) (*GuideSourceProgramme, error) { marshalled, marshalErr := json.Marshal(programme) if marshalErr != nil { - return nil, marshalErr + return nil, fmt.Errorf("error when marshalling xmltv.Programme for use in guide_source_programme insert: %s", marshalErr) } + date := time.Time(programme.Date) insertingProgramme := GuideSourceProgramme{ GuideID: guideID, @@ -82,23 +83,23 @@ func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, progra } res, err := db.SQL.NamedExec(` - INSERT INTO guide_source_programme (guide_id, channel, start, end, date, data) + INSERT OR REPLACE INTO guide_source_programme (guide_id, channel, start, end, date, data) VALUES (:guide_id, :channel, :start, :end, :date, :data)`, insertingProgramme) if err != nil { - return nil, err + return nil, fmt.Errorf("error when inserting guide_source_programme row: %s", err) } rowID, rowIDErr := res.LastInsertId() if rowIDErr != nil { - return nil, rowIDErr + return nil, fmt.Errorf("error when getting last inserted row id during guide_source_programme insert: %s", rowIDErr) } outputProgramme := GuideSourceProgramme{} if getErr := db.SQL.Get(&outputProgramme, "SELECT * FROM guide_source_programme WHERE rowid = $1", rowID); getErr != nil { - return nil, getErr + return nil, fmt.Errorf("error when selecting newly inserted row during guide_source_programme insert: %s", getErr) } if unmarshalErr := json.Unmarshal(outputProgramme.Data, &outputProgramme.XMLTV); unmarshalErr != nil { - return nil, unmarshalErr + return nil, fmt.Errorf("error when unmarshalling json.RawMessage to xmltv.Programme during guide_source_programme insert: %s", unmarshalErr) } - return &outputProgramme, err + return &outputProgramme, nil } // GetGuideSourceProgrammeByID returns a single GuideSourceProgramme for the given ID. @@ -128,7 +129,7 @@ func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID int, de // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.channel = (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) AND G.start >= datetime('now')`, baseGuideSourceProgrammeQuery)) + err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) ORDER BY start ASC`, baseGuideSourceProgrammeQuery)) if err != nil { return nil, err } diff --git a/models/old_lineup.go b/models/old_lineup.go index ddd362f..d5bc401 100644 --- a/models/old_lineup.go +++ b/models/old_lineup.go @@ -320,7 +320,7 @@ func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s log.WithError(extractErr).Errorln("error extracting dd_progid") continue } - cleanID := fmt.Sprintf("%s%s%s", idType, padNumberWithZero(uniqID, 8), padNumberWithZero(epID, 4)) + cleanID := fmt.Sprintf("%s%s%s", idType, utils.PadNumberWithZeros(uniqID, 8), utils.PadNumberWithZeros(epID, 4)) if len(cleanID) < 14 { log.Warnf("found an invalid TMS ID/dd_progid, expected length of exactly 14, got %d: %s\n", len(cleanID), cleanID) continue @@ -343,7 +343,7 @@ func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[s log.WithError(extractErr).Errorln("error extracting dd_progid") continue } - cleanID := fmt.Sprintf("%s%s%s", idType, padNumberWithZero(uniqID, 8), padNumberWithZero(epID, 4)) + cleanID := fmt.Sprintf("%s%s%s", idType, utils.PadNumberWithZeros(uniqID, 8), utils.PadNumberWithZeros(epID, 4)) if len(cleanID) < 14 { log.Warnf("found an invalid TMS ID/dd_progid, expected length of exactly 14, got %d: %s\n", len(cleanID), cleanID) continue @@ -492,11 +492,8 @@ func MergeSchedulesDirectAndXMLTVProgramme(programme *xmltv.Programme, sdProgram for _, descriptions := range sdProgram.Descriptions { for _, description := range descriptions { - if description.Description100 != "" { - allDescriptions = append(allDescriptions, description.Description100) - } - if description.Description1000 != "" { - allDescriptions = append(allDescriptions, description.Description1000) + if description.Description != "" { + allDescriptions = append(allDescriptions, description.Description) } } } @@ -539,10 +536,10 @@ func MergeSchedulesDirectAndXMLTVProgramme(programme *xmltv.Programme, sdProgram } if !hasXMLTVNS { - seasonNumber := int64(0) - episodeNumber := int64(0) - totalSeasons := int64(0) - totalEpisodes := int64(0) + seasonNumber := 0 + episodeNumber := 0 + totalSeasons := 0 + totalEpisodes := 0 numbersFilled := false for _, meta := range sdProgram.Metadata { @@ -720,24 +717,3 @@ func getImageURL(imageURI string) string { } return fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", imageURI) } - -func padNumberWithZero(value int, expectedLength int) string { - padded := fmt.Sprintf("%02d", value) - valLength := countDigits(value) - if valLength != expectedLength { - return fmt.Sprintf("%s%d", strings.Repeat("0", expectedLength-valLength), value) - } - return padded -} - -func countDigits(i int) int { - count := 0 - if i == 0 { - count = 1 - } - for i != 0 { - i /= 10 - count = count + 1 - } - return count -} diff --git a/utils/main.go b/utils/main.go index 099036c..fb542a9 100644 --- a/utils/main.go +++ b/utils/main.go @@ -163,3 +163,119 @@ func Contains(s []string, e string) bool { } return false } + +func GetStringMapKeys(s map[string]struct{}) []string { + keys := make([]string, 0) + for key := range s { + keys = append(keys, key) + } + return keys +} + +// From https://github.com/stoewer/go-strcase + +// KebabCase converts a string into kebab case. +func KebabCase(s string) string { + return lowerDelimiterCase(s, '-') +} + +// SnakeCase converts a string into snake case. +func SnakeCase(s string) string { + return lowerDelimiterCase(s, '_') +} + +// isLower checks if a character is lower case. More precisely it evaluates if it is +// in the range of ASCII character 'a' to 'z'. +func isLower(ch rune) bool { + return ch >= 'a' && ch <= 'z' +} + +// toLower converts a character in the range of ASCII characters 'A' to 'Z' to its lower +// case counterpart. Other characters remain the same. +func toLower(ch rune) rune { + if ch >= 'A' && ch <= 'Z' { + return ch + 32 + } + return ch +} + +// isLower checks if a character is upper case. More precisely it evaluates if it is +// in the range of ASCII characters 'A' to 'Z'. +func isUpper(ch rune) bool { + return ch >= 'A' && ch <= 'Z' +} + +// toLower converts a character in the range of ASCII characters 'a' to 'z' to its lower +// case counterpart. Other characters remain the same. +func toUpper(ch rune) rune { + if ch >= 'a' && ch <= 'z' { + return ch - 32 + } + return ch +} + +// isSpace checks if a character is some kind of whitespace. +func isSpace(ch rune) bool { + return ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r' +} + +// isDelimiter checks if a character is some kind of whitespace or '_' or '-'. +func isDelimiter(ch rune) bool { + return ch == '-' || ch == '_' || isSpace(ch) +} + +// lowerDelimiterCase converts a string into snake_case or kebab-case depending on +// the delimiter passed in as second argument. +func lowerDelimiterCase(s string, delimiter rune) string { + s = strings.TrimSpace(s) + buffer := make([]rune, 0, len(s)+3) + + var prev rune + var curr rune + for _, next := range s { + if isDelimiter(curr) { + if !isDelimiter(prev) { + buffer = append(buffer, delimiter) + } + } else if isUpper(curr) { + if isLower(prev) || (isUpper(prev) && isLower(next)) { + buffer = append(buffer, delimiter) + } + buffer = append(buffer, toLower(curr)) + } else if curr != 0 { + buffer = append(buffer, curr) + } + prev = curr + curr = next + } + + if len(s) > 0 { + if isUpper(curr) && isLower(prev) && prev != 0 { + buffer = append(buffer, delimiter) + } + buffer = append(buffer, toLower(curr)) + } + + return string(buffer) +} + +func PadNumberWithZeros(value int, expectedLength int) string { + padded := fmt.Sprintf("%02d", value) + valLength := CountDigits(value) + if valLength != expectedLength { + return fmt.Sprintf("%s%d", strings.Repeat("0", expectedLength-valLength), value) + } + return padded +} + +func CountDigits(i int) int { + count := 0 + if i == 0 { + count = 1 + } + for i != 0 { + i /= 10 + count = count + 1 + } + return count +} From 5925a0caf92edfa784bc7190b3d3a7fa0d47982d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 00:06:54 -0700 Subject: [PATCH 064/182] Update frontend --- api/a_api-packr.go | 2 +- frontend | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index e72a77a..565582f 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -11,7 +11,7 @@ func init() { packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/6RTXW/TMBR9768wfh2NRze2DMVBsK9uE3RDA6q9ec5N4+CP1PcmXfrrURs+tAlNIJ6Sc67P8T1X19mLImjqG2AVOZuPss2HWeUXkoPnGwJUkY8YyxyQYrpSEYEkb6kcp3xbIEMW8luwts/EADb0vUJgVYRScsF/O3jlQPLOwKoJkTjTwRN4knxlCqpkAZ3RMN6Cl8x4Q0bZMWplQb4abKzx31gEK7nRwXO2aV9y49QCxMN44IZ7S9VtYGJ0eNvJCc9Hj/VIvQWsAOinoiJq8I0QLUJSBk9qBRgcJDo4EcGCQkDRvU4mya7QiAKDNUWiETkznmARDfWSY6X20v3xyr87PrR+Z/5x9/NVoa+7y46WF9O9elbjUeOv/PJoOT9IL9y8m52vJ5ftWTg1x/VtWvd3N/PJmjMdA2KIZmG85MoH37vQ4tMx/H+MR2f+HGZ6777eTlV/1OCHdNmvT6+udRqK6f4Jztp1ATX5uDM7oxM30xdffLX4BDf753fvp4ftStflwTNhno0yMNuu8kwM25jdh6LfDkE1zTiGQHkmfv2OMtTRNPRjMQgeSNSqUwPLGUYteWw9GQdJvbUdSvnfCJtg+9JYi/8udcr4JyoxJMnE8Py+BwAA//+4MjUqjwMAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"H4sIAAAAAAAA/7y9e3fbtrI4+lUkrrN4gKuJKid97EpF9Utjp02bxGnsvsLNqx9FQRJjClRAULZi8Xz2u/AiQZFy0r33uf9IJIg3BvPCzADdJmyR3Q5v6XwbxTc/5xnbko60wyEI8XBb5GsUBI9DuPcG/OXOGy8LFoskY4iCAIbvdxHvccKQt9i/+9PDw0UWFxvKxIQO6d024yIn3Pd5lX6RUvlXgjf64u2XzfrwfV2oTsf3nIqCMy+bv6ex8AgR+y3Nlj06ZUWa9gmhY89md76Wso3rP7btPverBHzvFTnt5YInsfAmfbdVOTJB6HBL+TLjm4jFdGK/91QO4ftiuIn4jf1HFJdVFo6obExnolFecOo8qo9lskQMee8yRj0MdCgfsFjz7LbH6G3vgvOM68+9KOU0Wux7aRYt6GLo4YnsXwYJcQZTtS30dIp1kg9nW55tKRcJzYmcMDCpEadMEGpeWbShREzFUD4cDl7B5MPCG3vf8SwT33vQqkyNrH4/HO5Lk+ljxug5TekqEpTIkcRIfmi07PvuW7MMCFzqRe+JYZTnlAs5CW8iEa/pwh1xskR0+IZnmySnfUIu1RQ+vY04NYnd0zl8n/fWUd5bUEFjQRc9sY5E77hs7/+a3XJYpdk8SrFt6f+qwnNKWS/bUX7LEyEoG/6Tvcpy0UuTG5rue3EkQSvJdd1Rz1a6zdL9MknTug69pr1oKSjv2e6hNyZfwlZV2WibyBpZJnqMxjTPI77v3a4p6300xZLcgkjvxbK3z4reppB9yqJFL2MUeousl2e9OV1mnKpkWb8pPcQeLuFS7bPhgi4TJqdCru8eCfAkIHhwv6Ji7AJdxpGERUrEMC4415tfL+sEU1I9mxWlJVBWbCiP5ikd90cQZ2yZrAr7XuLTPTD1tzth6j4fypH8+w1cR/nNyUbef7p+MZzN5NzOthJka4DNIFEwezlcR/nlLauazrABVAOkTxvbvaeqGfe8QYYnyRL1aeDNZhJSZoskl83OvEEWapwVEQXiY2+QTRiKMFwGWUgShfyuMHAUQYTLk8ssd7TIJBIFTy/cyYlwN/C/POduexLlfKI1meVz5r+qdbiigrTxuqptRRVe+SMRa0TVzApc4R0H1QU0LI/rtAUbddu9oOufiIla7UZdxytPcdXkRBBRzadJlBi72fYy4zeNRhVAdOO5qy2Ne5x+KBJOF30PTxpz6aJcVa3G0hQ3G7zl0ZY06XSyRDXJ7Vckt92Ji7stjYVEMRVtWmVCQjLVFIyRjr4kTFAe060wHQKBgespNQNogwcf8oL9WER8QReIKVIDEV8ppiOXBKU5KF4w0uQLgOP7XZYseiNCJG1DguhXDFUy833EFBV1ErnvI24Sz8m9Xr/xOcghjWU/yong+/vTU5+wXXZDq7GqrpTLhEVpur8/J+cGgbZHYIb76YEc9fjfGca/MJRYYi8DqR1l1hFbpFQDjAFAA0i0/KxpkNiaHDN5ijOQ7fQV4LRB82lPRPlNL45YL2PpvjenPV6wXiLHRRVF7GXLXsxpJKvt99Az8yih19R9OKyw4pgG3qR3cUfjwmZQ49RfsKdQCx3mIhKSS9kfDnQoO98n5M6y0NXnmwn3fTqcCR6xPJH1XWfoBjaSQeQFe5YVTAwGmv0j7yfvCX1ouXRDhFzIOheRiHy/rx+GSf6G8iRbJLHvIzqMJYebPjdw8VkgKyfeWev/zEo78yT7bF9uVSf1YO7kBOrBtMYy7Zi9DdzgMaqnj4wMK1psF5FQw1DpiMKjMwwdNezhBvYYy51h4RDek6w8AsZc8qdFSo8g0oFGWbWGSg2WJygGIUTna7IFElgl88epbUkDsciaINe7XSfxWjKDC5rHlC0iJnIJzhK0M56s5FxrGPcGuiFVEisSZPbZ8RzMYG9xdhBOaHNtc8LAJJmRSODrQu7uHFUERwOOElkUOBw1fQuy8Q7pog1SAkNFPFt9VKjv1NKfyR2mwI2QWRcQzTDQ7vV+lcQ860BDEhW7m6gxdomLCnRt8SSofYdPNBCdagCyTzZxAXXeE/Vf7AzX+6/Uf3e6fo1UTm+Hv4GcdVUpXfwvoejj9Z6DRBua5rXhrh7Y58Pw/O9D8ENoqo2j5i6NIKNjaD2u54ip01v7eM9MHp1pLqK94RWdsAiMk9GEf8eGKWUrsZ7wwQCzgIcdnVdIXHJkSkzK95t5ls5m5COIEmGIyL1ck7HnQcZ+inJZcHxyV8npyzUoSk4DMnblwOdD5ZpwbAq/qMhaqygo2a0q7hBA+1FW8KwCi4fadoBHtVxC3KnGoZaZ0WAg7Bzm5H5jMc54BJuofqZ2I49HRhujUDJt6F4q3YwwyZL5f3el+ULfZ8OMPc/4zZSNhf2GnZzn6UrovDajsBnlJzfrs4JzKYgcZbf9GgtN5EyJiu+3fRnKJTFpujdOllapRr/qcqJRzu1hldjqplP6ZF8lADQ6KhNsL/XHZuaj/qnsos7e7JlM6eiWLnSiTw4qcTr2U52qe9fI1lG20U+3tDgq7fbYSW51u1HHib67+9HpvLudde+bGbuKN/rfqEAcV+COwE1vDaFZzYMwcTSCGqe4sNHsfZ3WASN1z5vZ2oVPwMuDfa5xkdPnGo3pPruZ2gUbfXaKimZRt891aqvPbgUn4Ty3Ha4V2iZRd6Yz+fKWUd7xre5CkaYTc6Kh0aAhQBPEDwel767bxlKyPuqO3GBRR3/Eqc44avHjzlA4hrvDAXXulejUHhAPQXY1uRiaoFI10wDnqBtUxWkgPGqgXteqgQbsRd1wJU5DTN0Arjn+k4oyyeI0uCpN2KbuiyFQqEnrajqqVFFjyacqfSouwW2wIictZUSjXYeETVspLu1BHfTtFOUyEvhYHHdJLssnmfqKYE2brxVcoGM61kmnHDlgLIbRdpvuDWvl9smhFJ3L0+8gZodDR2KTsqBOOnaaOkF7AU+I7zVzLCaVYuOIDB1hAok9muyyPkvtRgMYkNWDNqs9QgAdTTtj7NrlapD4cJD14wlNc9pTCmmb9znD7gsymbTWWquortvSmWyhl+S9TZLnCVv16grUwSSqj+9YFzh+hqDcwD3TdlIDYbXQVQtAj6dENTgWwzhK03kU35yE1U75tYKHGhoaBNKupZvYQICtQk6H23hOrWG1LH1RaeqauiG7KCwTRlaO5in18ISRusjppTEweTTMlhbQgfCjhJpatqG8m8TpHeiIzUnekIapVtvTvyvCHktLwAkLaAiZ+iN8oLZx9t2oDdmvMq5VanmPKl2BOhumrHdLOa3gXJ2/j/qE+/6oTzKDnNbu6BW1cKQ0Nqyev3clNjasnr93pTc2rJ6/H0G8jtiKjmkpwVNKycWJY38ji0IEMXbUFg7T09KBtoV6i0+UKsxjmbA4aGGsAJQWVp+xDPOs4DElXL8tIhGRBBqaoufM0vZKxRzbd739SKa4rsJoDuUnQ7gYIeTO9xPfT4ZFTn+cCgeHdB0SOp9V9YhCcXQYhMuyI3eLZtPDAWkeA8ObwcBViLuKeDDqU3MOYUpX2uwzQt74/gJhePPo0eedusrqPnEK+m+dcrttqTX+RGMqz987c9ULbcHmLf1Q0Fy4IGu2aFN9NTtSHja+dx3wOP3rKyVVM4G19ncFvQOv999GA6gBeOD997hn1et1uz2RyYzyM/RodZipWlA1DLz/9gaITb1exmUCkwljz8MDD3q3UV41o3s18P5b4g53g1Gg6qij48DE6NiasyKyK8ETtiIn1kufi+hjPXPKoM9INGp9sZi2k8YGVNqt6E2kdsFxN36+unzd7sS9/DquJhrUIPW7egQ932Nn7uszq/okAuwOGzewVllqLWFOPiIvp+I62dCsEB6GVKYYOxkPw1K+SsztYdiSIIQ16Z/V9luSR7kfEbU55d/W6C19H2WHAw3SUD4R+TDkNM/SHUUjjCGbZsEyRAs8pkEeogXIROH7W8PeOfZfC22e1F9rs4A16Y8mtpmJJlWUbCeyc5P6FGg0Ed9Rm0sMBpVaNhChQkGsiW6YOjbQZwf18Zskxr8xvboLQ0xxWZZXmgpJAnfOo4SdZ4wirOamLGVDK6t9fX3Ze3f5+sIrYX9MAmbEM6g9YSsPNtWr/HhDPF4wpr7MiacRgXq7JV7Bblh2yzy4Jl5FDj24IF5FBD24I15F+jy4JPclXJF7rSYefwRjoSP5h+dcdrXDCqiE4+GP30F75ON30DrAGe8gX2e3v7E4KlZroQu3mugnwUfkJSuWcfosY3lmWJZGMQ+HJSjLHXO6wjuxbGBzXVqjkITm43c67RUV62zRMcZ3JcwTtnhqiVpHFm06klPxOhLJzhq1jd1zGOr7XaaTFuT1HnA3QFk6h80K8tTe1RKxA4nwXnMSb8io3nTvEL6v98dHx7RzptBedRbgDWhpLFg8aJpHkqREXsE0TVvUtifaUM/3jcHeoStPTtOl78vfg7XoA2Vu5xpr6WZdM0APuo1eDc5cUeHY85zTPObJVmQcMtJJgCEhbKhHCpHETDFJXMxVyFeDuXLizWb2fOuaRzGdzbwJa+3u48M1NmwBMcKVSavvyzWVXUsyNhHTWEPwkGoeuKq6MjusMo89EL2E5UJu62zZMyrd4YbmebSiYwHepKetz8A5VpapanPJVLkFZQ/kvyUA3qT3e5QWspjobiEXUXwzNgY542aPJWoD1oHayJGZ4iSq8G9ttejk0QnRMF8nS4GwMaCw+NYaFzXYGG284KDepeqO0xJFuFTsbSoXtrCTa+b2rZ1arcngHq73i6zqvr3YiOqeaSgUQRpOeOc+VobXFf2ujygpvi/rfbit92FPgYaEvfrz2v1cOgS0Tn5loEmOXHZqIQeqOUsMK/myk4vrYdjLF8Maexhm8lUjEzMdv5uMm9aXK1PfDbF7RXVUUhmFaW5JfwTXpH8GFy7OuWso/qqlY1q0fY8ahisCq5T+mRI81Vgu2/DRP2tZoXW0YAWI/ggqVZjsZy2GyCbgqhpOz6DZRe82EeteIiSi8uBczoRjlqqwgAslssccEt27GApyibS9ESEkcTjg6/3WyNVX+nuwCAkhc10w1cpvOSnW0L7Cm4kLXXXq4YBSoiQzuRDOHJqpKNydUs8rRhhomSwR7xNy7fuJu91fyeqOLCQXuCNxJRODRdiXI3iHEgyyBZkCSbAKa12XaaVje6RYjjbVOySBAklY4Ribp/4Zxs6gTo+mVKoZNZ1cbfQlocEq1HO8CkkCNNjLqd77PifGkknmpsEmBJWFBrMQg/x4PCFqxfQSbWsD62uFQxuvhu9vpwV5ONn6foYSOIf7I7mtIdWdwS1PhP2i9ux4W+LS4so1GU3W3y0rzPYRUVgG68Eg7PxTUDYiZFnx1pyQa6xn6sIYVhzpXyzJ6qGE9bbGhF9Zc6CYJNj341r+IeSk1DJF8VDSCMGLWGRcFnNerY+DFNJk3VKQGeaqYLLcoxiP42ndDsKfko5ijAdIbQRFpabeP5k3MC9SFLRQZNZxJ8GkJsAkgd3QDJVQ2OkD+2odYacoZXPtIdLyxg4DaxshIYlZqhMRhcbeSCzCm7Rm0UFy3lnrHI0cLjSaNGq14E04YZ1bSZ2W1ZTmvmYYJHiDGd24QShL1cb1kQFJ5BqQSBQWBTy00+P70TDfpklMEYczXDaYyfpkQw5CbcSEyDYgIsm0izxO+Xjd5TqUTbPxbiI6JvYGXOJf0WA1yIww398TQliwDyeZ7yMWzELCgQWbkCS6RzERkpVAkbG7hcz3oz4hO/23ngbhOOAhnrxHDPojiJ0JU0lnoLkdTWlfnTAb0SbafbUaLjap7C1dlWeRi96c9iLm5rQ01igr5FLNlR5NoqtAi6LC9wW600t+i8E8XeNGn1Wa6XalPjutw/BqUDxiwxHu3fcCpmSZXpwtaNgrvRIq8aTDZaz3XlmoyS4gbdh8q6zbLfv7WUWubZEopm1HAglzpCrhCAoc3wtCgRFeOvsrUy0pS2vJLjnqgqT+wvQXsy8iMoKY0En0XWz3RmT1AgWJgyicbFGBDwek9aeVuFZIUqZos/I7sbPP5WCiNO12XPis8UBGRpBI2eU/0bmORXD5tCSgIWHw6FF2OAiU4LJEGQaGIRsM7JjMJ+DN0wJZvas3rP0VzQBdqmCWO3PcmBy1msKH86nZARr7ZsBBVjr+qKHcvh93I246AdGmvk7NgWIN6dHhk2GUW0DHHuj/RGIfsjdWDJ89FA4MKNBqKPYdmD5wmLyqtln1BJbvJ/ZBpshdov/glQIz9av684zQIA5J5bAHb4lrAdgheWN4QTiiUIvHkxe+338xdNmYwwG98P0FTamgvRdDy8OAm6iYGXghs5IHeaBRieFF02eoFn+Ct+FU/ozlOEp4MczdfELuEEJeqSxEjJEarXC1pkERHg4fkFBk+0gxgwTGJWTuaOEFxlBNF3mlZvE5vLQaAuMQ6RLwDw3X1UrRzwhHAoxaQbmQscOhf9YnhFUTpmi4MzW6HrkfZLGJCIqQZA/ur8YJnAU5CauvUDNXppkFpk8Asd4D5jw+eBmS/qiUEsIzfP8BPdOU8ymhwyUV8XrSQbGfKvtU9Zmg5+QptIS250YGOzoKUkx6QwCx3lh0YmfR2WPVNgpe2oWkZW19YhYqaEJ1YXha81WR3dzDIYngVakHRz+pTBInlEnMKfnGLszlEir1lNIeUcjIU86jvWvsIPkoSIgXLRZKQfkyyQVllHsQEY/TTbajR+kxMeqyanAJhqKVGCnFleAF9SAl3jJKlRKNtNR8E1cJ4YjpqkKDuZT7mYYNVyfRsmNplGmZzTsFSs2DH3UaFuS0WhFWZDHVj0YFBXuy8P3V4dDySm8rGWFmp/OpEDyZF4J6sCGBxNdhPQU3egosJWbEHgM8Opuw78lowh49wl3a2oCFSqJkIdmqPxADb+YNGMaTtuJmXtOfPjU4gDo4oI86NcIrKuyhkvJNyanQM3nbOW9/ZPyG8h/V+K/ibEv1lLg7rZUFrkkfeezWS1hvj50jLAW1Mc1z3/cCPd89kxJ6hJD78kggqwpguCD9a9/v38qB9ReHQ381/On61UsThgDDHflPNPNQC+YE49j9gdDDYa8P+S3Cvgy0bXw4EYcDct7JDnmXr2dv3l6+uXh7/Zc30OnYuuMorKacytQZw+Gwx4EIwVgxdiM+Axl2SfnhwGUNW666dE6XUZEKJHmZsobRc2Q2nZGulMWMIieJ72e+TyVPhH0fJeT+U+fFSmBu0htDrpOahlcpioBPND+cSGiEmCQSCqEgfJgX81xw9FginsugCCf54YD0Y2vuJOeZNCl3wytYTj7TXnpIkL063kMiyEPfF8MOtIgKuMIQ+35sZxo2GLo20VRVQyiI4THOlZUojdNYZTGHKMkxI2L87GUvJQzVHaWyo32KnaMfS7+CPGx6Nsu3yBL3SMrU9RmvMoyxOdUsOWJ91j2sYBbqE4UGikMcQ3bkxaygJ3Hl9vfuaT5uqgKEqwo4l3xRxryBCHgIzNhD6TE4B6hJL2E9ij3VwcTCxQgeY9/PNKub1D4rERlNou8yV3KR7WRBJJsojeZkhzzrMvfCoK+WykTvw31A1VwzfL8PdohiKbjIxOM1FOQG1c7JFE/y20TpGU1X8H0c5bQ3UoffwZtQMfxsMuc0upmoT2fNT0gEoxC7GR53ZAARnDVzPTmVC0TwuJn1ywezggieVPkXGnuM225dfNVLk1z0RJb10oythh4uS3iF5CTJVVWrD5lpwpm1Uq8al+ubYe/PVy9/EmJrLEskdqa+73GabzOW0x/SbC7T+OHgSpJdqp6AhVPZuMOjs/CEaUXwJgxY6ODT4E3omhWNBWpWBQzuc/fMV3R2QkxRXT3ZIgF04A0lAYdXzhcQEj3UGUUJp812dJ6yxCXiztQx7FW98/rK6Zsdq9YVApcDCXhIWMDDpqJNaApQ7TgiJonv91saeo4nOCFM7jdJHeS+VYRB6FWOICY7pKmHLI8ikgRxKNvWTySRO30uP1KUAMcYW71ChiKIFeWRXWxPQHFM7SSIqeqiileP6jG9MsGHAkkqzE63JjiSTxelll77Z/C2YUXyQpt4PLMI8+3kGemPqsM5SlZDFu2SVSQyPixyyp+ualn80ZlipBK2oHeXS+S9unpx0fOw7x9/uObJgjLxRde3i8WKfuHhwwG9Jf0RhrfuEV/H2bZlYNwzbYuSnpuUDj03MNI5N8Blei2tZ/LVGD80QxM1IkbUkC9pjmEmFNQyhT8TfKQMrEskU+FuQOZuwE/p6RNsDXYJITY+kImZQgMeasJYBx5SzUQuGNXFnXOZmNAgU4Xj48Jxt9VhJ0dWThK1q+GBdSCJYYFOjnRy8ssJpNah9J1W7K9JCL1xdKLTRoB9Tu6LnP4oOTt4KRneD/LnKfni/z2S+dA/bwcYSdnwoORC/F9fwE8tyXDLs220UlYPVyLbbunCkRVfK56BWw5GnXJHi8XhkECs3/jmcIgkYyhfUsNi5YeDNiyyPFfuwdbmf5qmh4OV0tLUybImO5RhKR4OvUE28MYerIi35XRL2aIWjffq+0p9n3XZKvbpMMnfqgYWdcwHawE7acmRqmPGGnqn4mWhOnuXMrGRG2ldYna0YwnHUAXpkH0LWGgiiRE6zLayynyS+X6rO5nknzIWU4nJ49BwhcC0kV+7pWk7aVz3X4rhJWwaujMV9kBIGcQRirQq6XAQlWhDlTX3y0C7J4RBGqqtx3GyRBI5cstCzRCXHAqzxvM9S7EyKTCoQySJo0aTpOIAfR/1xeHQV3aTwU8hniSDAZ6hLEh0RWUJN/+JTuf//3Z64kj/aucoPwKDrPpn5qysP5pwR+pWFOtHRbL1o6Hbesvs1jBrl4jXN+fF1vfRrHrRpebKaqKRl0uQnquHmiO/JWIiJenbdoCsCb4lDN1qcfNWgmEmGYpbIjD0b+vBJEt0G6zD5uiu4UIipDsiP5HbIAvhktwGOxRj+RqHcKVeC/VahHCuXrfqdasMbPjQbHrfR9fqa5WiclVvZke9J8m0SQD7F8Mkv7hLcpGwlSUVd3orXRhYgQsNSa+jDYWLYRxtRcHp9Ga8gQu7QXE57tj/D1Vk97xbB7xxO0hPIClBXga0rimUnIBaw4lQQYREQKtO5uPUjF1pHqw6whB1jmtYHk2y7yzMT7LBQO4DHmShZG7wPbeHvJmOyVF1ifRHMHK2i8KJUZo6n51GTYACJZIodbKb107/pfESsLNGG7PmTj99ePofrshMv1MHvDOBMZPlcqr/xp2qdMMpTdoskZ7kiiYQiYhqxK2/tigAkXLDR6X+DI4Vt94PL58++2X28sXV9cX57OL3i9fXVx4O4ZmD80wshBiKauiVWjD2fRST/pkTVarwfVSopCMReGuQJIU1qfiJ4EyBSn99zEgda6+0Dlfv9g7bpLUxvXZJ4ierJP2RhJJ+dDhESMAatq6xlur0AlZOZ0ch7J3Xx6rvHysw35DRZPPdRwvmGw3mK0LIx2ATfs4Ib+QIq6ncTxekfzbuV8+jcf+sTkcL0u/vfb/f31u4hZs6SdJug4vhlrjacrgmL4290jWek+tgoXZyrWG5I8sBWg1SDJf6KccTWUJiVPkfpCG50095SC5hThbTy/Gdkpqu4Jxsg3kI781qnauleS/36kxNlZ6m86NpeofOg00IaxsdTxlZ9XRdJAgnWjWzbZn1wCvyIXgTTl75Proir4JViOHqcEBX5M2ADVa4xoBkDze+j6p3NUMKUi0KJdsaA5OFi1DJClxcTt6b881k+lxZRU+e+T56pgx3ziMRkQs982/JbTviDrqCNTxTQrVVylYdUMfCR3XpY2rZ9b3pspT7nFG9rbv/1un+20b3d76P3raxwxpDMT0fFkybwL7F43OtNXuLIZ5uzelHWZa2q5KUkmfoDhbwHt7AHMO1JMoSOp6ha9hDB6q8/tuUCubQH2EMklK3dGnAKlTCm7sza+5OUev6M8k1yY2UmSOQTO4S/WPnzNoQtbBTUhOPk4eKGotcQgKshUViKMhLKW8WCl8WgXBI51JiURbEqqllhUy2ZDTZ1rZ3W2tksSZLyZ+oHbOGpAomubQ0dCtp6LpNQ2urPLQ+oqGydQNma2397ASsWWOYT5kFhIcnoixBMlPHZtiarwgkL/GHPboAd+EwdEQTMuIekxMnjAFGW+xoJ42zikTWUYVlx7YdalnbG9YAJKPT1ZzNy4qfsefjAZdSCCTqybD2mVUsZJZtn2gvoNFkXRu5rQcD5TleS1RyAhmggkSSh22Pr2iPr6jFqqLeNEqNIpuMSFJJDh3Na5Xa5H+pF6U2jrWrvrSKixu6z5GwHVq2OrQjT4f0jsZoKTsAC7Lz/Z3cfwul5pWgWsnefUIW2vUv2LoDWOCynXhcWE3UHDsKkRJeISUg3GH1FIdwieHc9+XLNoRzDFf6pQjhCkN/VNbSSxDCNRlNruvDi+vBAN8G1yGZIxFch8ArLH9bayD/cDk+5ziD6+MMA2hmSriUAKU8bvBRYiTARPJ2uK3QspXFZDSJ68WPBwPM9D6Kgjis9VNMEe4/yQ4pV1Tlh+Wcd/ziRBnVO1ISqUTbj7OBsYGOyL0jdsao5meVUXJlHDKM+EpuMXJkWGldc08gFuteKyqz56MwkIcD8lixmVPuWKnWLpDmXDEK6rRwXD+rUDT2JfjTYEPtZmKTSWb6RkGPAoOoV7Rw6F2CaNPdEpcZURarA8LBPaE4Nn+z8aK7FKEST6o5zckaCZDvcF85dOpFqaZj7KmoIrsoVecisKBptB971n1Sn5U080yT4Cw8HEZj67aQj5NS8f2KvuV2z+TGueXIpdTKK8eLkE4jyS/m49T3USrnNseQ+n465HQp/wqmHroM9oenv5hSKJd5iMo5nCdsgVIMuf5KTC6bjqHducMhnabjvKzB0yxxgstS7ju5bAwecvyodwYkhEvq0WommWYkCpJwjDLlQBH8GeLDQb5gyHzf07bojvJNqY2mTT9MybRol1rfR1nlW+/7WXsvKE6ncqLFvt/eHEm9J5JwLHFKUgE+ZC02IMN1iBeqYthpc5DfDIYPdshrmip5ODxhw/SDU+aUAZRT+qSN1F9HNk8/SxRWMNfGIHcx2e8NoyPq+zT4OdS/gQjrvfzjURgf00qSP+fZRyo37uGAmrZziilnx2aKsubD4bg4xYfDb4jCz3Df9r+4l2Cn+4VMx4hihR0XrV9rjOwEKfit6dukEUn/yMRPn9AmtZDJLRg0M46Phscnp1tqEAaVLyNHLhZuqOCMMMfXorSufWm2Qt5TIehmq1zuRdazPag877Wn1KKCAJmeyfSM9cwJhnHe70Vs0Vtloqc8BqG3Snay0mI77nkDbp29/osEXjTPs7QQdEF3SUwznlAm1EGEB566oSFh20LYly1PmHrZbtU5SqqcoD19vYJJ2fJssxVVqi2i3wqWZpEsottLk9VaVG+bzDTc1ZlWmu159W3Ls7tkk4i9B946ytc6iogHXhqxVRGtaJVg/DflU/bRdDPS3cyWyzRRfrgZMw/20zZa0Xyd3ZrHdbJQX7OtiSpRO5wY90UPvFxkXLdUeUJWuVSimY4il5Nb93/HF0m+Tfdxxpi6sqNOi/aLJO9M33KaUybMMEOglAQeZTHfb3XO2yiRwLXM+A2VrWxyRunCPGcfVZQtXmzFnK4SdpRG2cILQcgqVZ9DYPJ5nhbcA0/BmQfeMouLXE65HhanefJRjj6PeZam9dTr/CFwVUdWsFjmWiYsyddq2iIuvBAy25xOAG/LsxWnuWwimmcqyTZtmnRyCEPu9Tc5ANmjaLFXC1ZNUyIbKbYrLvNQulBTFWebrUQMTkN5Ece6YtvkPM3iG70GlOdJxioIi9Msl3VHsm79UhfLtpQ5UBhCrBbKfK2TC6o2qG49YslGwb2mSm6KHln1mgjKqy1c3MVpEt84m1RvZ7NuVWVxxCQI1U8SVRYruRj1oLLNNtOBQux6OEk6VFEzTfcsLqgzMbo3dk7ijAl6JzaUFSonr7Mu5qnNveDRyvzpKvWToNw+3yXCPKY02lHznO1Mjmwr/wo9L1ULCtmq9aNML/sxHKt/tRfUk4amVSa2mQ5Jp1UnHnh2XhO2i9JEVnVD9wsV/UE+bQ1I3tB9sa2B1QVtffeJ5GWqlw0VUZWQtxvdZEVOTSPq2U6JerEToV6kFGif9Sj0467Orzqmnm7XVAGFg22rOdtGhVo4Ay3yTxlYeFXvDESZd9M982Y7aF5tF+1rFt/USDr72JV8S+c3iXC+UF73zU01u6lRi03tqER/MElmttSbni3zwcyXeVMz5iAcXqMVhfuo6MSBOaUaa8gHPXlytWJRPbgTrlMslBgClBuUVJHgvJhvEo2l8q3eIxL9VZtyl6XFpu6cyIp4XS2VejNjVs+2NfViaquCBNXFqiSdxZAX+aQAKJRMVBwJFMgJX6Vmr3MqqaImSE6yhPCjJBsKwlKLwIsKkbmo2XmtM4lstUqpzi+5Fs0vmQBnFSY8Tj2/fPVMNsvES7X55J4v0jSPOaXMhcqOVA1PXdnzjsQ6yYHSduJxpVXmvJ3WImvg7ZI8mSdpIvYVpfsvCMzg42y7r2YiLhx2LcoNElcZ9CebKFFqA101CU8FozTi8boBILxgjXebVY/xiJIdJbr07OhTs5omPKrlj0Wy0xtAQUK1HSKeRNxYU9qhO5l1wqKdRBeJsLTBcLQV2aNp6pBKJniWVttaYvFoFyU6SKF+z6lh1RZOQg3bammr2pdJKhxMl0b7rHBzS3LqEoad/dNTKp8cHkqJki6mSj5Syx/JZ5uVZ7cWY8tHTWR5dptrqcm8JCynXFi2aRMxy0BFuWIw8zhKkzmvOXlnWtc0VWQnj/Xe+5hlG/W+iViyLVK7zBaw1WDyFc2FyypUKYusmKdURFs30UyBfV1naePdDrZKqIp30PlNnjDKRRLVpbpJc35MD6sUS7DzI5pYJawtVc6PyGSVYNfXvhuKnjepVPWu6VQza54IuskW9H2x2aZJLuSrVhbryRHrYjNnUVLxYLlQTJSRaORCJ8ILHf1CTmvBnPr+e0RbkYSUSF5b5hvbiaEGbtShZrI2RYQQWmpNHNf6ncqGqFFbplRQQx2qqo4vVTmytZqq1JbK1DSrTE0pLnFpuq3up7KjTClSxgCyK9eHw51VSna6BdH5lWQulA9C0zgGXciyvt+nyHGfcWMVZkzPPPb9rrqtw40NmIYeqkKd6Pj+sTrE2gyVeiGaVuZORRmhiMvqWmTGeFDcixPf4WG/mG6L7v7I2lkmpN9HsTKPb3YOD9uNVYt8qi/Z4XBfYkhKrbHfIW8Z3cgx/Ed7r+3Ro1DFImuYzpgPhNrhxc3ApvaU+bNHTApIlNc5IaSAuCuHVoyXNhxWSoqhuUpR75FZxpzb+uRqXuicS3NN7iSnaAkFrXm5pgiPIQWGlhhDTtG5ufbWgZ2CQnXtWp+Q5fDq9x8NqPq+rNtJaBXLu8C6+tS9cRqfX9FFErXzUDePiqt3RUU723/ZQTOKnQI/ZIv9Z2dWtbdzC7cHLx7KNDHn3srN7lXEPxTUZp2s1RSunSK8KrIgy6F2OpwsVLaFky2W2cqcotN7vqpoRYphM5sT4G+yUnWvfH91XBi60NaL8x9eSBTr+yinyL45RRM7MS/Of2j3yv16uaXsU3nOIxHNo5ye+HwtOcboyPy8keNZwfOMH3/EkKthVwjeyRCpqaVpTvsdhgAdMTVIQZU7ENEOX5Ocpsu2x5xouzAAl5jZUEjt9EKyadYyEtLeNWMbj1K+TLIJzpQnbV/+BUsa+j5CgmyRfAeOsUwj6iVThvoYMpKZy9Kqa637I1yCDuNZNOJ4UiRwiTC8Q8fOS2ruXAM761bAhjW9ZEMHxg6H14hBENeTHGJwcpN2bQXkkNZGDaZn359NzfXMwPS9BjESGJaEolQSAKt6q86sl76vbM6WDbo5RQXh6qSNpBAkEEmRRzO9Wu03XGb8IorXDTaj6HSMM6EBjlz0CSHJ4aDiAdUHyWYMo6kIRqGxSGmYarTsGxuOoAxP0oCHpAh4WB1+pwG1Hl6psp3GeFyQFN6jAtqKy1pvrlSYIeQYitIEs3aXz0J73ktYL8ZFkIckDvKwRCMojKfhkurzqnlWsIWHJx3uO4VI0nY4SjZsxQ8l78Gk6gii5COwYSNgKLkpO6NfimSj/B7clfoFUbmiSr+Z0kiOvA682/GxOkfu/rrZSCIkqIe7u2Dk0KdWqFXEoKNHtbxayRRHZUz7m+zj2yrvJvv47OHsWniuS+j3k4W6B6FU4UeeVk3//sCLUmoFUH1CpDYV33hhlwGUOnoOeAjuUbMTAaFK5s5NZVUEGBV2igGFRDlfnOi1g2ROhT0Vn7YYnlDt7Cfk9pLP+GgS+l2WzlSjuIlyWq8wm7pkvgZkxJrhy7NtBU5vaqchr8vssIkURfBTqAzGfb8yMlFOv1rKUb/suN+6o95TFq8zDk85jeBpsUgy+OEt/BDlVP08z5gAyRLBD4UQGYNnEdtFORhlGpxLEgbnCaeSIO3hPNnBxWZOF/A8oeniigpQVTzP+AYUjIHlyOCnt/ATjRbqJ2Er+ElsUtDcErzYRCsKL9i2EPAL3a8og5cv4GU0pym8pCvKFvAyYTfwKtqCYZtAsYPwirICXlEhnwTl8CpbwKXqpT6rhsut+JFnxVY+JBmDy0LIVt5EPFrxaLuGN5zCG6P3hV+LTFC4UupEuFIaH7jSgV6vthGDK7FPKVxLyvEs0hXqF5qm5ikzD/r3bXarH660Khiu6Z1Qs3+dCJmJR/EN/KZ6/Jum6fB7sqCZB5x4T7fbNIkVXDyL4jUFBWamQ8+TlL6l0YJyPXMayp5pdauenmdadZXKidH4/k3GBbzOFhTeUL7M+EaiBqjZdusmDlfriNOFZjpVp3VPq6dnBa1fVPf/oPNfEmUKu3ieZrfwhw5AYqpox8xo8hJwki09+vLbVu56qFlKOOYfwWEWockZQsUGgmFXoaJ0nrI7FcgD5Q4ahJAQOrwVS4gIc75NlA3McBNtO1QPnuTs1cG9mVCvxFaY4HhMXV5oatz6G6gLjzPCJ7XhGx0eXZf/4mIWr2l8czj0z6Cov1OmPsc8y/OZUbo7ObfkhbKirKPUzWY/vL384+ri7fXl5cur2bPL11eXLy9mV0+fXzz/7fWzzqB1sCOjyc7hD3fW7HFBlgOEbiQDvAvxIMWwkik32uL+xljc3yiL+4V+ykOy0gaIqlLm1mknYE+iYBfCjHwI9qoObXNfd2BjO3AzmQWq+U0Ykv3Aa7HdY29wU2qPLmunqNrNWmO5JTTIgl0YTuZ6hW59/7ZG3rh8jSjM4X637rgqM1mifuz7W/VUYOtRnSl/D+udah1l/+DRdku5CtKCVLyqypwEHw4ZIZVOjDoX/UD/rBWy9vi7DSL7H2zSVqkHJRqmL5/ojaMMAkMUHaAnrzXJqtw5T4uoypnTobCsVRmiEGQN8eId8l4V+ujzcp5TvqPcU6kaY3V/U4xgrpF280uNd08xULUeZu+QcwMfKUUjECeuOOlyv9W2Xp3hkL1nEWOZ6EV5nqzUjR+cRgt977DtQWVxlC173oBWXm4NMciaPDYiLGg3OWtChqE21uq+DEYy702mo2l1Ziyn2xIVw/fdF75QYCACFsp5plWj2kaus6lWAGjRNloTuEp7qEfKD+/HRhf+MoHePmHN1xlX7gf1YoVRvabKVrdpe3em4hY2gkjWCmaP05VEZtzSlkRyyQujqLNcrn0fHuWWNM3Tc7d4ZgzePfAiISRr4SYtaCspssFxnumjm+pTODnV3pEob+1Sj1jkrD35diT2OijinZ9oYjz2BgKkvFrVKNFsceyCa23Lc0JRIZch9/1cB2aaIvNAtvYJYgwRQQnJcWN14FfE3aYgIwIS8iPSlyhDJAXuQIRki+QfxFp11JMvvo+anyQ8mRD3dgK1JSK8QidXkOOyRCeQTqxY9a7oGFSpGzUrb7WN9SU7SkppiCxO/IUf0mzuaHjosfH8pBkE1rbn2skLbScvhvH8xeKuoTahD1vKgzVTtydHIIy1OlVW6I3zEd3Xz5Ce9CbpQh7m/pjWZA1t3boXYwpqKOORNi0XZalqnlTRDNTn78moO+B0YDKE0zUynn91GnBI9EUk45Zsd2Lh//zp7bGk3j/eS/npA6GU5EEcwpLkQaGdxFLr5voQIU6WaGsdXrbO9kvJTle3C4qwNJcqdNg0rNy7d2ow2st1a7YaJCExvvAWtkDK8gYmIsKDLJykKqY/123zoAgxRL6/1DuMwwIiTflylb0RUWSoeqduaVCHkeeXry98vy+Gyl6PLny/1SEpeeemwEq+mMAUuPIuTOuWcww8YOHhgOQfoRjmZml5BdEdQx6BE/tw1riAZvPAZtN9lsVvT2yfUjvofkS5tV9sH3x10nEa8JCMCFFRs2gQhUQF0bqpjOmV1hHmumqtR/0bVU/nTkXj9bG2eagrnMF9tQ8Lno5lP1x3kf6ZcRGpnT8EmFkZ989K2MNGdfNWd9MYZT7Uz2qujf+c6HB00PEx9BU2RZoS5+bKw+HI18f0xvDZE9FyUVB3eMgdb6Ik7pB3t+banUkHLrpb86s9i23gors1r/3CILE5qg0mCZpO++3ty1Ns64pmaRYfa6EEvhd1LCg5hjowlFPi+BygDogn2p7OzpV4VURGFmQhRETCvgnzJ3HRHFEkIMHWO1RZ4ySsoN5E7ZL2IrUXskFf3Oh1XJ2mJLjeta+QAIpBlCjCZWnClVSCaTIY4AwluEQnJgECb0XVxcaUiTfGcFZZ04l4Xb2HJ+b/+F4dhW5bSliLA7o9ePC9dshrc1UV3a6iMjcbclw/E3VmnSEB9/b+A2YvMgBOozxjY1ZfA1HiCbcIUDkbleWJNpRidfc5VwmFhKEuO3sMqoKT90Goci3jfYw1/QTv7Dp/6h1Fq6BDerfNuOiWXu61N4uARcbouN+nZVnC4/GxoFZXwpC3fv3FypPNPb5Mnn9Oc0eucpX4Yt1capGPDjx7VW5UrXvfc+LlluA9ebl/77W6aAQ/5P3Cs589POket7t5s56UMDBHFDIQcoOyZkNffnW9e6Ch11/HPysUxZC3f3L7rcJNDHmXb578pXASl5w6xISruKgF4VIkg3aHJEKwcqhpPzbvRp5NUC1dSQTcJ4RPc3XBEMPW53vC5ZDR/YqKV8Yee9xJjmTBDAkMx8eO3z2Z6rrGBXI99LGCe/C+/Pb8y787IXrQcjJyKmwXtSTc2UvNhOv5yBDDkCBetf8yOW+37xU57UmKFQtvUnVmsX/3p+3Mn788/82ujgYPiOSzgiQMsXx+9/XuubrljSHvKr35S93yxpD37erPb9Q1lgx5oy/efqnusGTIo/T3D+oOS1n/q9/XHoa1fF7uz2X6TqXPPyYPgCIsYAV7PYEzwgMawobM4IaspupobuxFi4UHc7Lx/Y3D1N6S+xKuO6jDXMU5RXOgUsxVho+E0Glbauijve/3U0QxVlcTVW7YKoj0dDSmuBx76yj/t8qvqDhRvmeLW3g7WYecgRN1dJdRl6G4kYDce/67SgAzZXA56Xbp3fg+2h8Oc0t2fL/fsJJTN5Ns8JAywROaIzxk9E5IicZI5heK5GzgjlwENyHaT+/L8aMRnOE+uYBL0qjsQiINdCap6BVpKuFVJcrgD85Jf+/7jYK14YZuTJCvJuLRowmmsk1R62f66lJx9GiESzy5OhwQ2hCBmgxOjgRsoNKn7dQQZyBgcxShuk+Y7xeIwQp4cBMCx8BLjGtoJXOYuzwS2WBAl4fDOfZ9dI0snGK4RgrgMKx8/1o5nHoYAzrX2qFrdINh7/vzoTqurq6QMO9aF7EhC4lqnzmXbwigsIIbDBFytxDDEA9fX1ycq1hpekBrJEcMtwENyQYylA1/HGTDPwbZ8Pn/gzZ9MsNwi2F/OCwkKrsSPGMrWQRWGDaKXrz9sjhNDz1nEqCpwpEcvnNHgFVuvsgvKqs+ENnLLI5SagJ/VhFAFQG/XLrnOyV4Xz9/dfkApjaITCHHiz82zyrkOLr7zcPIy7c0TpRTbjc9V+jGzluGqPJcbhF4dHRLAz4cRJ/oCw98v5+5Og6sonqbeySBI4F9X4saBAnFN8s2qhxOJCsxVRWOhVyCb87T9d+nUJJMR5pSWQqlF+hhOpp8mo5GnXT026dP2efSsdvN7kfb5fyrD3811oQhTRMx8l5F24f1Q7XEcKSLqu113Ngq9k7Psjy6hbyiNoqtuWCC71FmgnjITmCJNizCldRhd2xg6kwhHy7o8qh4jZlVYEeubbc0If4s5rY+qmreISLw4VAHOvR9E8XjmAllA2/cS1iccU5j0ZO8vxaAjhjRp0v28TMX8eWvT+NPMSOvipu5ZUbWb178apmRX6PzuWVGDHOROmzm0t232gNFRfndkj4KQnUI4PueJEhewkwCwpJZ6TYILk+zKzvLsEh8L2CnqcMMNnAD82N+v7/1fTn7vbsqoqLkTkxAdaojqXuyN95YPSpElnvjk3BrwpubK1PLz80Ht0QMvN4LOzVwTWxbhCzggvTP4K5xKc8luQuW4eFwF3j/5/9UUxoeDgvfvwsWIVyRy8NhjhaSDi+m19M58gzt9/D4yl5F8p54CjN5Sg99Z9mDw+FS8hnvfR/dkBS9N1fu0NsexRj327cn+v6NYih8H+XoBm7lfgB+OHRwKjeq3xG6gSWssYr5den7driybqWi8H10Qfoj9/aL43iJ+mZ5DNz3+/vDQa5m/0IOXzdwB0t1u0IgQnIFcXAbkjUscLJEM6Jlynx8Pb0az5FtHINc6/FKJ6p1x2CmZHxewl4HnZMQM8Pq7+5wSNAdbGAWbOzFoZIqv9EUeXs4XGAQMKs25aws4YcPy9//Nv43mlYX/+vjr/8d/P/s5ub6dB83ozdb28e/Nh92FldcffH+C4srGP1HYnHFx7e32Ukhwx7QnRFCoSCP5V9Onsi/lHwp/5bka/m3JV8RQg+HJayJOBzi9lW6EMOu5jIVJlByKcxIhvYYNoSjGHbwBMMNidDMur3AnIzglrDpGgm4weNCPYys2Dq5+X4+mevggnJN5xoCfB+tyAYtyCyYhzCHvSQrWBmR3gbzkKyqi2RXuIlTek/G9kBeX5DwlUUpC/3+tX2f2xsZbrUhxAJXVgBpHabWTsT00dk413FobsuyhPPfV09Pr+LH9dO5XUXFF7or5BzQOjchOCGjJWBJ1HXxy+jiM0iMbkaClYfRqIO2GOFWwUv88fUvlra8O//6G0tbDE+YOsLtsmY6YEsiuU/+oNENrEl17HxxJyjLE8mh7kgxLJbKZRYWUkRddYXD/g/wI3vS4kiSJcqlNGpYky2qeJC+5hF3aGmYDDkCxWjgoTKowGMxFYG6tW+WhFUkxdM8S6F4llZ1YPiVGenkz2w+uW+ggP5IovFJitrz8U2faHELSzkDITPXS07pR2pP97GkPt/oISxwKfdLjBAnxbEAtGqMuCZyewyRlYAgQ4FXeUpKKQyU/KUthMOOU9dZ4w47ofUOUtZy8EVmlkWy8v21OqbWs7yUvL5+UrIqtz5UJjGgoSpu7TZyo0eQn8dJHQOqFuZl7lLK2yVIceb0tnz57g/R2Ir69rUkV/9dm7Gi4eY++wu6+el0/b99iJ/bbf/2/fkXFnlHz56/t5sx2m6u7WaMotWd3Yx32w+p2oyfsMCYiKHamGz95crD0/wISpVZfoIoBkEiJBS3oI2aHPWfcC/8TZYo1mY4lUTX50NzuijTgQYilIN//vMfX50e/Dq/jboUohJTHostpvMnLG2OhiQlzMpqkEGk6U5MbMw8KMhoEn9fTDAfLpGKEhkUg0GobVtcnv35u/hDawByl357LpGfRNwfBs/0k1L/qqfiqVjoJ8le6Kfl6y+e6Kfkj8GVflLSp3q63N5J9N8Y8urJ6isPD9/SZUpjUcJPX6+XpydTT+BpZjxrBJXKpgJxxLAKUh+chXgskHv1u95fdGgP5ZTIU8lCie9zlJj1xhiEpG/ei39Egwdkab2V9Gpb+cNqJa6jlVp8r3JrUBuojesqDF8i/KCyARhEx3ejETr1fqs8t8ZGXUCn3usiTb3x8SkmOr4T05k/CeDuFS3I3uso91GG8ZSNkylHAo+9SxvIG0VEpuBOQwitaqR06kzBOCpLeHH7zdnnKWa0BruygJKcKsqwXKrMWIlZ19oTE2fZ1OlRfknz7tUS/zz4mj6wxAoCjpbYETGTWlSddEH6igordRlvlyOSbQGwuh+NBll4ONBjuSsJJPINyxJ+Ti6OmXGJDTsx5pVyhshLkF0/PcjfrymXA7u9ySvklX7I7fjMKujKICJdIR8n6MEF4AHV9hE0JJHvJ/o1mibjDCNP1zz0BhTjEg8V/0R4CZJ/O91r93jDaA4Sh6BE9TCQl/NY0ZvqAptKeVgQ5HmDGFvlYXUNEZ7Uy5iwfEtjY5jfNb7YYo4SOidC4au48j/vsBqa5L6PEsTAY8p153DIqhdJlxQB6qvQ+chmjUyuSH2cet5A/o+L4fssYcgY7wqMZWkVQE9+Jmwcqwf7lpmZHSOjUJbpYFPliqD2vT/QdV9T66b05nVKJhJuFB4OcUPELuGXQhzbWrcIgV5pSX/tSmupQq/0X9e7p3KlX1zM3ry9vL5Uy+30rGz6b6tjAhBqi99+c6a29dJ4WnGSWIsASXHFMBf7lA5N5DbisYxRT5K4AX+58/Aw2m4pWzxbJ+lCEmUxzHlMvPfRLtL8ytgDRLWZhKBMaL+J2qxzmG0pQ5JS3vJEUOR9p4t9X5kJPje7+7t/fmE+KcKqXP4QVk4Czyf80aMJNitYOHfGJQEPQ0s3CoTLthSmUaPL+lVi89GRK50ix7VTMYSg7/yOwf2gbHOYcqDHY0YK1NBWS5gzd9a8/PVpfFKj2T8rQdLYztsnnDtPH0b+zO5NE2v6H/DoTF3t9/Wv7x/g5LT+8TTiP7q0+OE+VHwG9X3Eh6osUdqGxN4tIntU3Mw/j7fUjHUnP3lcvlIzL82B8pnc1WWrHYcNIAwkp/j66/gB9Ks0+B0KXUtMqoBocoMmGqkfDsg8SZhBDHlSvPckgopbNgHamiUyIqqyXMyaYUkmkRIPqbmVkWvLt4Rkqoww178elclUGclLmDKWR3A3xr3q5DiCTbQdx7CO8hMTofyToX/WOhMk5pasXBGF1ZEk/ckKFLo2GjRupqAtkGs1f6y8LfsjbGZD4FJrGru2jTar6J9JNBdUeEFZbbc9oZXIrzVDQqlCVcVdd8zUDOnh4GkfTPd6WTo21Ehd/nW3bVSRoWx4BZ6RCjylsi7h8s2Tv05DnyHymaMWTE6QgfaVdG0M2LyivFMjRYmUwYCriMtTGiThuPM6aue0T6v/q8OXxrdp463u27hRRHdvGinOXk7K9u4BDHHKHEdZKWGr31XmOI4lyuZBDW9teqZBTbaJaiCfZuMEI4Yh0jYqkpj/+oTR053UliWfUNbWkCnnu38GOhy8ujQMWFnCr9F5eyK6T54kb9GlkDAnSSocfMVCogi6Ef6JoyJXwG2bjLmUMoJ7Ru/EWCPgEkOiwqw7xzKSBLz9K/mmc9++isR6GNMkBa6fl2mW8U+IPfnr6DWiZEDxdDRG9PvRlI8Z1locPRd/z1TODbGDznyKj8LsoMcyrQ4Vjb6U78bATolbaq+eBo7d+s1vJ4/cG95GSPIechwSnj7vKOGnr9dLu/iS+FdCgt4qsXOsoLRRSjTEkJP7ElIJJeo0/wRzvwRjLr+2h4RkO+3Q9JbjQqKRGeFIFhLTx+MzrLweuy0E9w9ZCCr4nKe0r4M7JWiP9fnEWuJ5e/wwWX+/sZcXoRUR0xmK0I7QYBMqbclOaUtmSCVgQkh+OKwIIfYEoLcqqwv/FmRv2alJH+3Iwhj6SCGd0YlpIkMLmMHOuNuIE5Xi4Q9vL57+QnIQw7cX17+9fU3SEq6ffPu5O/tzDQOumiED/qOGAdFi0UUPm6f6sgNSBqvP9dUW5LiE3z7EzzvE+fty2GUDU4Jkr06Du5ZXXeUJJCQLvNkszjh99D6f5crvezbzpAB+4gu5L3G3QO8e/WkZXv7VlxeJqRjfl1JktGGWcw+CEGse4t6kjfnQPMEmW9BxZR4w9bYFp97YWyk/cg/ibLvnyWotxt4/76Jve49HZ//onVOW5L03Rb6+iTjd9dDHNEt4Ft8MeYE9SYEkP/p5igMzYYmjRIico6PYwSFFJ4eaQyr3PqwJ9Yvhc9ip/x9hof7fwEr9/wB7spvysXy+mvJAaG2IUFM9RjrhvnRPJ2ZkN83Gmc6amaywcc8dDgfkvBF7E7mK5LLTdyBiYHhJEEpJf+37e+eay32Qh3i6HzMc5CFsycr302mMlsDxeNGp0FtO41oTIJEALPF4CXvfj9AecliCHN5vGGZBHvbJ0vcTNIMcthgWvr+xiUg+kSUuJ3woYY9kUAyfkzMohj+Sx1AMr8iXUAzfkH9AMfyBnH0NxfAP8kR++Y18LT+9JWeP/+EQ3qKEP1/9/oACoYOeZ6R/Vl2HnZDgmzDgIcKTxCiIXWVBRvqjErTAt+TZBiUuO6Dx8+PSPU84tXfU7aa+38+ad4CyVmekzKQ7FCkM2zZTuFf26kx2rYQTt41HJSiT/bpjlt8vS/hz/jH5PDVs8tUi9pR08YBNueo6RE13EMvFRVpz1QFUkbrGNXLM4GRW1/SDowT7fub7mWK9lWgq2fxP6zONiYWj0HyYs3C1lJlhL/7afNj9jcM0w5x4Hz3cicDRyJ74dFAN78qq6yVzM6VWJ+nZ+8M15/bu693zB5RlRuUp2Xo7eLOYLfWoVikMlxCTERRdR9qOKOSEfISc9Ksz8o4zjQJVIpe6P8/Ul7Ec3ZfKNTZtzH+k7PiNJ8Z9MvYuvUFvMIjhVmnpcQlLh/O6/+XirzGH1xcX5+P+GSyjXPzSkErtTlNraE9QO2RS1PLyolPvyht7bzw8oFp7oK6Q0dUVTnXPvYl7U7F34U2U+tdxdxsmSu7/g0Y3HX07UXF/NDm6AblV7W0JGXuujsK7OI/c95fqVNv3C2WWapryfVkTKPeWd+dff/OZPJZxEMhqG4rKBiJxmOfIAbPYcRpoORNoEw1tY2FAsWljkaOvMKxJjr7GsCMjWHTtVDqcpYcDkn9KjbPCDVsLc8wekSAsYd/Nv2wRHUZdXCENRqG6ixaXk5VLXrttQPfWzk55DlYhboOzsDzSG1UbqF+V6bKx0AShrpZNWXAWEjHWY9KsVEBBhLgErfDt6NZa2xdEXRdCCT1CWlql0/8IrZsfRvZuRgFnGPr9/xFl6RDa+6ZlxbEuKqm98J0vRm2QgwBvlijN9UwQIf8SshsMQK2isRi07AmX0MuBAQ2SUE5U7X6NcodLuu+YAHXHpbOlLI3Njkxi2HRhbViEFGBUTYjiMZN7hYExiMGVpT2rbGTaS/svNqoVhMctliWGXC7uqdPxDKnz//6oUTefLpSaW+k3GR7zQM6xVueCsUsaL8oSomfPH1B9G5O77HMFco4ssZQb+pSyvmnvf1L/c6S016cE0XbzgLmgRjsna1SBqOuV6VG9MpBZV98WU4IYodXhgsSgHGWkOkaobUS6nWVUaeOT8InC/X+v+WPNgPcsYv8tenHGdpQLe8+UyHpbnmwSFehJ9UtpmuKPr3/5TBqgrVc0QPycXESWlTCmPpGjhI0dAKoYCh2+xlmgfnE4dPIP2nvnvgQhfxjRJ8MIAydeNI8XdLlaJ+9v0g3Lth94LrzKsiVgIfkGeM0ydQb2FJK1oyWGb/qkQPclUKw89914MSpd7k11iup5uE942TxXcWMlyk0PRSt+KeTkDFKSDZewJMlwOSm+zyf1nbmwJrFjGJsPBqEkd+mUo3UVUCxFa4zHMgUWZGcrXpHRZPH9aoKNedIatmQXrGQNUuYLtiFZB9va6IeV46IEb/HFj/EDmre3fyXfqDVWysVNdAeJeUzYJzYr0geB+LvRNEN0oCxbE7t1pbDdiRIct6CO2MM6oLXv6/+h7AlR/ZnqlHFXoZymS99XMXmdAvJ9bOVW5DnaWw8j3L4CcTZb+T6azVaE4RIkjH6Wg29tStPvU+TIXBXXLElp+q5tfPVp701z9JfUx3xGS/F3nJWUe+Uk8X0pgIogClVwHiQggvvPj5au3L9B2379K36wLTejppn5L81zK8fQXJ2+tMzMH3eZmZ9ZM/Pl/rw93UcHqsOl7qZhRpOTxlwPyL5U+XJRwqZ03IhfrWyVKCTtGbZKcTmbqyerrz6xRyrVmfd4+NXwG6/sgluq4JYquNU+6g/DGhtyyUUw5D1/F3/QZnuj6z+2Hgaz77QezoSXL2H95sWvJzfDfVmCnNLPs+Mwpp6JYw4adV/CeWTs2Zmn1WayVAcEIEhiDEA5Yhgy1wrUepw37UCV2W/CeuxwUGa38rGlg/eeqvvlMq718Hmx3aqQH7V/lHb6UKXV/ZgiJExzBVqDkXy1iD9P+1LtnxZbo7ZEv/YU7BMiWl0VA2/cixVjkFPRi/JeBZ99DzcPvakwigbJQzYORJE3m6lys5mXsPuyaWZgrvdEzpHLkaaQIe+Cbn6S2w0dH8eCU7fiXuExxohCEMr1O/JgU1o4Z8kE6Y9ajlCux3Oio+WKKR1WzRA25jqZlqUk9/0z64yBQcXUHCcSyym71v9I+IMbuu9QILfDHvRHD8Q7UBK9CnhQOk6aD3voFJ/20Im7PHTkKp4euT5RfgAj2v1XW/3U7LdxVmHGWeWs5e/mWKMYOzE1ZOOq0nkw3coP3JZ40lXCCU7tllE+J6dPh6qIXU4Us7IERv/xgCb1iLM6wU7VjXwv2Sg1ed+ORt+cffvt46++/ObL0bffnuHxSLa2/nL1QHiSBxVz3/S7cazcA17kHfm51sXKEg8jCRb5Vx8eOG39TEnscKDDmejEVt4Lpm6jEsk8pT1OY5rsKIeeinHZ4/RDkXAXzSqT9uKpWJzu1PWTbys/pF+fMGp3qdm9rSNgs3sLkmh+JdcPDZVlTaIL7R6QkNgYKRkb7MTCOzOXzqcocQJEWrv9qQ0+NM2UxwvXESMl9x9hjMfRmJWTpBXV5BSblKLoYTYp72KTpJD/uUFs7IZuOw1b6TNK095GGTv3MtbTMUmdxbp9HD3gQGG8RDLnLF7bIEvp5RN6iFrTBQzMZQwxFMpEHXKSoaJyyEtJgiIwNzj4PusTExVnkn+f6lPsmBRBKoWqPokr5FwfhKuMqTlUp4dD2ktYr8C+XwRpSAiprs6S3w6HURV5wvcfnUmkcbvZ/fiZokCTUTX2LImjnY2cY8oHta9Pl+yj1b6qUEk2lEv6rgrlYgSMtaPxNSp2HdLFaGoXZDv1Zrk39vSdmauu7QGcrI0hnvfckzSsDj48SwKu4zRLRne2nLAJI2zIlIvj8MYhGazBpTysg8zt5UldOsi0UweZIX2VvOyE1UO6OkkaLELSqZrMm6rJBKWualKF5XCxaR2fZGc1gKDGngDXU8AnnPAhw3zISX8EfLhV9qJbwofbIauCQ1T6SD5Mwonqd7vDJ5XDzGmekxViRnldRRDjQ6bEte2kunFdLtYwCcF0TF3CP2Qkw5CpO/63JMHAZEfk/CD1lKmUtEpJVZ5gET56ZANG93kJRk/T7KbtoOPzxInklTruiXExmvU8f4IlME3ZkI2NS51Wvkj8ugM2vFG6VqxvdOATLCFve1phv0L1lFGlnt1KyS5t3PigtsEJCloVDxahLJ4+oN2FDBKyQm484WSaDHeEjfWJR0Luk3Emd5aSbG7GAnZjBtuxgqIUmJ0FrgIiUu1vqMAkUf7siA+ZfJSAMhiA3ppyIdWuzEKSYBWQ2Ua3GK+givfS6rNypoMm763nXJCdpo769YZYDbeF1BI6d4fJDsI8pRMVRYNPsCBiuJ046ojhTAWdM7UKIqaiWnIxnC3xNEUj0CfByoFyeDOuYx/I9904EBIchrsQj1HVcT2BKTrDuAQ2raIbVKWhz9TsL3U0R5AC7SfYMo1Zff9fY9EcV4VFsvPw5zFskrP5lxg2R3H+UIw6ZtTMRyzZPv3QbX88svaLPGKLbIMepunGNQh5lilyHd+8MQUPzzxAgwEbcFwHrH/ytTqO+Pj2Njs9dhUg6DSzamkPvdWmhmqZ4eP66QMGuK5VsuFkFJmWPI+HUf/spLPKw/awEGvj44KMILe3GzB9YRPrk0jiohgY9v1cHw8yjTgn1U1UxQSrLEQot1Ds++h/EpQDw4dDVaZawVwKv8oN9F8OdbeJttrQWGSc1kHvJDk5IbAadfpJMTVpiqmKHijJVpvPO7wp4YdDn9cHevWZnKRyQ4mom+J2QWLrMmDFZluaYej3C1XmcIhtqtBhMCEIHsMoDEM8+f8CAAD///HcrHO+6AAA\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") diff --git a/frontend b/frontend index d9a6003..d9bbbb5 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit d9a6003a3c7e736b22cf3febe24182ca3008740c +Subproject commit d9bbbb5a4776254abf2316364d368aac0d5e92ad From e1fa360d14bcdb23d5079c40745c19531f849c98 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 00:19:44 -0700 Subject: [PATCH 065/182] Fix XMLTV tests --- internal/xmltv/xmltv.go | 7 ++++++- internal/xmltv/xmltv_test.go | 6 ++++-- 2 files changed, 10 insertions(+), 3 deletions(-) diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index d64d7f5..d9fc59b 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -5,6 +5,7 @@ import ( "encoding/xml" "fmt" "os" + "strings" "time" "golang.org/x/net/html/charset" @@ -25,7 +26,11 @@ func (t *Time) MarshalXMLAttr(name xml.Name) (xml.Attr, error) { // UnmarshalXMLAttr is used to unmarshal a time in the XMLTV format to a time.Time. func (t *Time) UnmarshalXMLAttr(attr xml.Attr) error { - t1, err := time.Parse("20060102150405 -0700", attr.Value) + fmtStr := "20060102150405" + if strings.Contains(attr.Value, " ") { + fmtStr = "20060102150405 -0700" + } + t1, err := time.Parse(fmtStr, attr.Value) if err != nil { return err } diff --git a/internal/xmltv/xmltv_test.go b/internal/xmltv/xmltv_test.go index b3767d5..fcad44f 100644 --- a/internal/xmltv/xmltv_test.go +++ b/internal/xmltv/xmltv_test.go @@ -39,7 +39,8 @@ func TestDecode(t *testing.T) { } ch := Channel{ - ID: "I10436.labs.zap2it.com", + XMLName: xml.Name{Space: "", Local: "channel"}, + ID: "I10436.labs.zap2it.com", DisplayNames: []CommonElement{ CommonElement{ Value: "13 KERA", @@ -76,6 +77,7 @@ func TestDecode(t *testing.T) { loc := time.FixedZone("", -6*60*60) date := time.Date(2008, 07, 11, 0, 0, 0, 0, time.UTC) pr := Programme{ + XMLName: xml.Name{Space: "", Local: "programme"}, ID: "someId", Date: Date(date), Channel: "I10436.labs.zap2it.com", @@ -125,7 +127,7 @@ func TestDecode(t *testing.T) { Stereo: "stereo", }, PreviouslyShown: &PreviouslyShown{ - Start: "20080711000000", + Start: Time{time.Date(2008, 07, 11, 0, 0, 0, 0, time.UTC)}, }, Subtitles: []Subtitle{ Subtitle{ From afb12a4b71f71ddb7a9f3e32995ce0bd784d3a44 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 00:20:02 -0700 Subject: [PATCH 066/182] Add IceTV XMLTV dtd --- internal/xmltv/icetv_xmltv.dtd | 607 +++++++++++++++++++++++++++++++++ 1 file changed, 607 insertions(+) create mode 100644 internal/xmltv/icetv_xmltv.dtd diff --git a/internal/xmltv/icetv_xmltv.dtd b/internal/xmltv/icetv_xmltv.dtd new file mode 100644 index 0000000..88c7a8d --- /dev/null +++ b/internal/xmltv/icetv_xmltv.dtd @@ -0,0 +1,607 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file From fae8bf68cf1f52e41708359db1254053fdd31d0b Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 00:22:03 -0700 Subject: [PATCH 067/182] Update deps --- Gopkg.lock | 20 +++++++++++++++++++- 1 file changed, 19 insertions(+), 1 deletion(-) diff --git a/Gopkg.lock b/Gopkg.lock index 5407795..7b3cb3e 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -184,6 +184,14 @@ revision = "645ef00459ed84a119197bfb8d8205042c6df63d" version = "v0.8.0" +[[projects]] + digest = "1:65c6401efaeb147041aed03d5b18862ce666a54e4ce754ea6ddbfa5ddaa24b07" + name = "github.com/pressly/goose" + packages = ["."] + pruneopts = "UT" + revision = "95600eb369b1f657efd54a401ab85d0647a1db80" + version = "v2.3.0" + [[projects]] digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" name = "github.com/prometheus/client_golang" @@ -286,7 +294,15 @@ name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" - revision = "3d6704d3b108deaffd476ad2f27003dc38bf775d" + revision = "e76717848560ef3975a9d20b559b1b1639383e00" + +[[projects]] + branch = "master" + digest = "1:9076b1a43fe4ebebafe54ec06e7f61591fc64912e434a3d3c667ec7740662638" + name = "github.com/tellytv/go.xtream-codes" + packages = ["."] + pruneopts = "UT" + revision = "33a6daa3da5246cf599b2af0a3e2c19555ed560a" [[projects]] digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" @@ -395,12 +411,14 @@ "github.com/kr/pretty", "github.com/mattn/go-sqlite3", "github.com/mitchellh/mapstructure", + "github.com/pressly/goose", "github.com/prometheus/client_golang/prometheus", "github.com/prometheus/common/version", "github.com/sirupsen/logrus", "github.com/spf13/pflag", "github.com/spf13/viper", "github.com/tellytv/go.schedulesdirect", + "github.com/tellytv/go.xtream-codes", "github.com/zsais/go-gin-prometheus", "golang.org/x/net/html/charset", ] From 7f391a2810acb07541a7205ffafa26be7e28401d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 01:22:50 -0700 Subject: [PATCH 068/182] Add String to LineupChannel for pretty print in logs --- api/tuner.go | 2 +- models/lineup_channel.go | 4 ++++ 2 files changed, 5 insertions(+), 1 deletion(-) diff --git a/api/tuner.go b/api/tuner.go index 8f7ca1d..520c8cc 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -192,7 +192,7 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { return } - log.Infof("Serving channel number %s", channel.ChannelNumber) + log.Infoln("Serving", channel) streamUrl, streamUrlErr := cc.VideoSourceProviders[channel.VideoTrack.VideoSourceID].StreamURL(channel.VideoTrack.StreamID, "ts") if streamUrlErr != nil { diff --git a/models/lineup_channel.go b/models/lineup_channel.go index efbbffd..6ae7071 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -46,6 +46,10 @@ type LineupChannel struct { lineup *SQLLineup } +func (l *LineupChannel) String() string { + return fmt.Sprintf("channel: %s (ch#: %s, video source name: %s, video source provider type: %s)", l.Title, l.ChannelNumber, l.VideoTrack.VideoSource.Name, l.VideoTrack.VideoSource.Provider) +} + func (l *LineupChannel) Fill(api *APICollection) { if l.lineup == nil { // Need to get the address and port number to properly fill From 5bb885c39519fb50b7666ab3e186424ff12eb9b9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 01:23:15 -0700 Subject: [PATCH 069/182] Rebuild Gopkg --- Gopkg.lock | 59 +++++++++++++++++++++++++++++++----------------------- Gopkg.toml | 58 ++++++++++++++++++++++++++++++++++++++++++++++++++--- 2 files changed, 89 insertions(+), 28 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index 7b3cb3e..3ad16d2 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -48,36 +48,36 @@ revision = "22d885f9ecc78bf4ee5d72b937e4bbcdc58e8cae" [[projects]] - digest = "1:489e108f21464371ebf9cb5c30b1eceb07c6dd772dff073919267493dd9d04ea" + digest = "1:d5083934eb25e45d17f72ffa86cae3814f4a9d6c073c4f16b64147169b245606" name = "github.com/gin-gonic/gin" packages = [ ".", "binding", + "json", "render", ] pruneopts = "UT" - revision = "d459835d2b077e44f7c9b453505ee29881d5d12d" - version = "v1.2" + revision = "b869fe1415e4b9eb52f247441830d502aece2d4d" + version = "v1.3.0" [[projects]] - digest = "1:35534a9283f212bdc542697dfca3c2700f2b2b1771e409476f08701b44c1709a" + digest = "1:b793158861dda5660883cc91ed3ba69b9b4e3bccff97feb08c34a2fc11b93228" name = "github.com/gobuffalo/packr" packages = ["."] pruneopts = "UT" - revision = "1aab5672bd385f2a7da18bffa961912e7642ea79" - version = "v1.13.2" + revision = "ee1318b82b25993be2f7161d48315e1f14697528" + version = "v1.13.3" [[projects]] - digest = "1:15042ad3498153684d09f393bbaec6b216c8eec6d61f63dff711de7d64ed8861" + digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d" name = "github.com/golang/protobuf" packages = ["proto"] pruneopts = "UT" - revision = "b4deda0973fb4c70b50d226b1af49f3da59f5265" - version = "v1.1.0" + revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5" + version = "v1.2.0" [[projects]] - branch = "master" - digest = "1:a361611b8c8c75a1091f00027767f7779b29cb37c456a71b8f2604c88057ab40" + digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10" name = "github.com/hashicorp/hcl" packages = [ ".", @@ -92,7 +92,8 @@ "json/token", ] pruneopts = "UT" - revision = "ef8a98b0bbce4a65b5aa4c368430a80ddc533168" + revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241" + version = "v1.0.0" [[projects]] branch = "master" @@ -106,12 +107,20 @@ revision = "0dae4fefe7c0e190f7b5a78dac28a1c82cc8d849" [[projects]] - branch = "master" - digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" + digest = "1:be97e109f627d3ba8edfef50c9c74f0d0c17cbe3a2e924a8985e4804a894f282" + name = "github.com/json-iterator/go" + packages = ["."] + pruneopts = "UT" + revision = "36b14963da70d11297d313183d7e6388c8510e1e" + version = "1.0.0" + +[[projects]] + digest = "1:58ad79834dc097c36a857a8c325d646af0a8bbd73375a6958a639507c5399a61" name = "github.com/koron/go-ssdp" packages = ["."] pruneopts = "UT" - revision = "4a0ed625a78b6858dc8d3a55fb7728968b712122" + revision = "6d1709049dead37ead37808479f88c9bffa2c4d6" + version = "v0.1" [[projects]] digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394" @@ -161,12 +170,12 @@ version = "v1.0.1" [[projects]] - branch = "master" - digest = "1:5ab79470a1d0fb19b041a624415612f8236b3c06070161a910562f2b2d064355" + digest = "1:645110e089152bd0f4a011a2648fbb0e4df5977be73ca605781157ac297f50c4" name = "github.com/mitchellh/mapstructure" packages = ["."] pruneopts = "UT" - revision = "f15292f7a699fcc1a38a80977f80a046874ba8ac" + revision = "fa473d140ef3c6adf42d6b391fe76707f1f243c8" + version = "v1.0.0" [[projects]] digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e" @@ -290,7 +299,7 @@ [[projects]] branch = "master" - digest = "1:2f6be3c7ff8cc65d5f6b35c2acd928aed1386fc31dc11483045b393660698244" + digest = "1:933270bbac9095788f6e3ad0e11331173170627176ffee27e722c3e7e0bb38be" name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" @@ -298,7 +307,7 @@ [[projects]] branch = "master" - digest = "1:9076b1a43fe4ebebafe54ec06e7f61591fc64912e434a3d3c667ec7740662638" + digest = "1:e51bee2c46f96d430b7f23e2824cd61c5ad2229b50d6618b0f1132e7947f4d54" name = "github.com/tellytv/go.xtream-codes" packages = ["."] pruneopts = "UT" @@ -325,11 +334,11 @@ name = "golang.org/x/crypto" packages = ["ssh/terminal"] pruneopts = "UT" - revision = "de0752318171da717af4ce24d0a2e8626afaeb11" + revision = "614d502a4dac94afa3a6ce146bd1736da82514c6" [[projects]] branch = "master" - digest = "1:2d073118530c09a068ae1c47b054b5bdf75f625621658ecb642bcad7e65eb66a" + digest = "1:5da7f8d7b8c0e04d5edc9f8a68b6199bc162ba379ac0ad6d3983a6f4c8125587" name = "golang.org/x/net" packages = [ "bpf", @@ -341,18 +350,18 @@ "ipv4", ] pruneopts = "UT" - revision = "c39426892332e1bb5ec0a434a079bf82f5d30c54" + revision = "8a410e7b638dca158bf9e766925842f6651ff828" [[projects]] branch = "master" - digest = "1:a60cae5be8993938498243605b120290533a5208fd5cac81c932afbad3642fb0" + digest = "1:0dafafed83f125cdc945a014b2dec15e5b5d8cd2d77a2d1e3763120b08ab381b" name = "golang.org/x/sys" packages = [ "unix", "windows", ] pruneopts = "UT" - revision = "98c5dad5d1a0e8a73845ecc8897d0bd56586511d" + revision = "4910a1d54f876d7b22162a85f4d066d3ee649450" [[projects]] digest = "1:4392fcf42d5cf0e3ff78c96b2acf8223d49e4fdc53eb77c99d2f8dfe4680e006" diff --git a/Gopkg.toml b/Gopkg.toml index 546090b..841aa1f 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -26,16 +26,44 @@ [[constraint]] - name = "github.com/gin-gonic/gin" + branch = "master" + name = "github.com/NebulousLabs/go-upnp" + +[[constraint]] + name = "github.com/gin-contrib/cors" version = "1.2.0" [[constraint]] - name = "github.com/koron/go-ssdp" - branch = "master" + name = "github.com/gin-gonic/gin" + version = "1.3.0" + +[[constraint]] + name = "github.com/gobuffalo/packr" + version = "1.13.3" [[constraint]] branch = "master" + name = "github.com/jmoiron/sqlx" + +[[constraint]] + name = "github.com/koron/go-ssdp" + version = "0.1.0" + +[[constraint]] + name = "github.com/kr/pretty" + version = "0.1.0" + +[[constraint]] + name = "github.com/mattn/go-sqlite3" + version = "1.9.0" + +[[constraint]] name = "github.com/mitchellh/mapstructure" + version = "1.0.0" + +[[constraint]] + name = "github.com/pressly/goose" + version = "2.3.0" [[constraint]] name = "github.com/prometheus/client_golang" @@ -49,6 +77,30 @@ name = "github.com/sirupsen/logrus" version = "1.0.6" +[[constraint]] + name = "github.com/spf13/pflag" + version = "1.0.2" + +[[constraint]] + name = "github.com/spf13/viper" + version = "1.1.0" + +[[constraint]] + branch = "master" + name = "github.com/tellytv/go.schedulesdirect" + +[[constraint]] + branch = "master" + name = "github.com/tellytv/go.xtream-codes" + +[[constraint]] + branch = "master" + name = "github.com/zsais/go-gin-prometheus" + +[[constraint]] + branch = "master" + name = "golang.org/x/net" + [prune] go-tests = true unused-packages = true From a316485b3dec7b61d4a8fa932f80642710337bb1 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 01:33:53 -0700 Subject: [PATCH 070/182] Remove the sdProgramContainer --- internal/guide_providers/schedules_direct.go | 57 +++++++++----------- 1 file changed, 25 insertions(+), 32 deletions(-) diff --git a/internal/guide_providers/schedules_direct.go b/internal/guide_providers/schedules_direct.go index fac89af..c515604 100644 --- a/internal/guide_providers/schedules_direct.go +++ b/internal/guide_providers/schedules_direct.go @@ -63,7 +63,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } } - extendedProgramInfo := make(map[string]sdProgramContainer, 0) + extendedProgramInfo := make(map[string]schedulesdirect.ProgramInfo, 0) programsWithArtwork := make(map[string]struct{}, 0) @@ -75,9 +75,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } for _, program := range moreInfo { - extendedProgramInfo[program.ProgramID] = sdProgramContainer{ - Info: program, - } + extendedProgramInfo[program.ProgramID] = program if program.HasArtwork() { programsWithArtwork[program.ProgramID] = struct{}{} } @@ -125,27 +123,27 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro // Now for the fields that have to be parsed. xmlProgramme.Titles = make([]xmltv.CommonElement, 0) - for _, sdTitle := range programInfo.Info.Titles { + for _, sdTitle := range programInfo.Titles { xmlProgramme.Titles = append(xmlProgramme.Titles, xmltv.CommonElement{ Value: sdTitle.Title120, }) } - if programInfo.Info.EpisodeTitle150 != "" { + if programInfo.EpisodeTitle150 != "" { xmlProgramme.SecondaryTitles = []xmltv.CommonElement{xmltv.CommonElement{ - Value: programInfo.Info.EpisodeTitle150, + Value: programInfo.EpisodeTitle150, }} } xmlProgramme.Descriptions = make([]xmltv.CommonElement, 0) - for _, sdDescription := range programInfo.Info.GetOrderedDescriptions() { + for _, sdDescription := range programInfo.GetOrderedDescriptions() { xmlProgramme.Descriptions = append(xmlProgramme.Descriptions, xmltv.CommonElement{ Value: sdDescription.Description, Lang: sdDescription.Language, }) } - for _, sdCast := range append(programInfo.Info.Cast, programInfo.Info.Crew...) { + for _, sdCast := range append(programInfo.Cast, programInfo.Crew...) { if xmlProgramme.Credits == nil { xmlProgramme.Credits = &xmltv.Credits{} } @@ -172,8 +170,8 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } } - if programInfo.Info.Movie.Year != "" { - yearInt, yearIntErr := strconv.Atoi(programInfo.Info.Movie.Year) + if programInfo.Movie.Year != "" { + yearInt, yearIntErr := strconv.Atoi(programInfo.Movie.Year) if yearIntErr == nil { // Date isn't that important of a field, if we hit an error while parsing just don't add date. xmlProgramme.Date = xmltv.Date(time.Date(yearInt, 1, 1, 1, 1, 1, 1, time.UTC)) } @@ -181,7 +179,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro xmlProgramme.Categories = make([]xmltv.CommonElement, 0) seenCategories := make(map[string]struct{}) - for _, sdCategory := range programInfo.Info.Genres { + for _, sdCategory := range programInfo.Genres { if _, ok := seenCategories[sdCategory]; !ok { xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ Value: sdCategory, @@ -190,9 +188,9 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } } - entityTypeCat := programInfo.Info.EntityType + entityTypeCat := programInfo.EntityType - if programInfo.Info.EntityType == "episode" { + if programInfo.EntityType == "episode" { entityTypeCat = "series" } @@ -203,7 +201,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } seenKeywords := make(map[string]struct{}) - for _, keywords := range programInfo.Info.Keywords { + for _, keywords := range programInfo.Keywords { for _, keyword := range keywords { if _, ok := seenKeywords[keyword]; !ok { xmlProgramme.Keywords = append(xmlProgramme.Keywords, xmltv.CommonElement{ @@ -214,11 +212,11 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } } - if programInfo.Info.OfficialURL != "" { - xmlProgramme.URLs = []string{programInfo.Info.OfficialURL} + if programInfo.OfficialURL != "" { + xmlProgramme.URLs = []string{programInfo.OfficialURL} } - if artworks, ok := allArtwork[programInfo.Info.ProgramID[:10]]; ok { + if artworks, ok := allArtwork[programInfo.ProgramID[:10]]; ok { for _, artworkItem := range artworks { if strings.HasPrefix(artworkItem.URI, "assets/") { artworkItem.URI = fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", artworkItem.URI) @@ -233,17 +231,17 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ System: "dd_progid", - Value: programInfo.Info.ProgramID, + Value: programInfo.ProgramID, }) - xmltvns := getXMLTVNumber(programInfo.Info.Metadata, airing.ProgramPart) + xmltvns := getXMLTVNumber(programInfo.Metadata, airing.ProgramPart) if xmltvns != "" { xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmltvns}) } sxxexx := "" - for _, metadata := range programInfo.Info.Metadata { + for _, metadata := range programInfo.Metadata { for _, mdProvider := range metadata { if mdProvider.Season > 0 && mdProvider.Episode > 0 { sxxexx = fmt.Sprintf("S%sE%s", utils.PadNumberWithZeros(mdProvider.Season, 2), utils.PadNumberWithZeros(mdProvider.Episode, 2)) @@ -294,13 +292,13 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "deaf-signed"}) } - if !time.Time(programInfo.Info.OriginalAirDate).IsZero() { + if !time.Time(programInfo.OriginalAirDate).IsZero() { if !airing.New { xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ - Start: xmltv.Time{time.Time(programInfo.Info.OriginalAirDate)}, + Start: xmltv.Time{time.Time(programInfo.OriginalAirDate)}, } } - timeToUse := time.Time(programInfo.Info.OriginalAirDate) + timeToUse := time.Time(programInfo.OriginalAirDate) if airing.New { timeToUse = airing.AirDateTime } @@ -315,7 +313,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } seenRatings := make(map[string]string) - for _, rating := range append(programInfo.Info.ContentRating, airing.Ratings...) { + for _, rating := range append(programInfo.ContentRating, airing.Ratings...) { if _, ok := seenRatings[rating.Body]; !ok { xmlProgramme.Ratings = append(xmlProgramme.Ratings, xmltv.Rating{ Value: rating.Code, @@ -325,8 +323,8 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } } - for _, starRating := range programInfo.Info.Movie.QualityRating { - xmlProgramme.Ratings = append(xmlProgramme.Ratings, xmltv.Rating{ + for _, starRating := range programInfo.Movie.QualityRating { + xmlProgramme.StarRatings = append(xmlProgramme.StarRatings, xmltv.Rating{ Value: fmt.Sprintf("%s/%s", starRating.Rating, starRating.MaxRating), System: starRating.RatingsBody, }) @@ -474,11 +472,6 @@ type sdStationContainer struct { ChannelMap schedulesdirect.ChannelMap } -type sdProgramContainer struct { - Info schedulesdirect.ProgramInfo - Artwork []schedulesdirect.ProgramArtwork -} - func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo schedulesdirect.Part) string { seasonNumber := 0 episodeNumber := 0 From 84af8fafb9c09dc4d2eaca094f84a14e0e12fdef Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 01:35:41 -0700 Subject: [PATCH 071/182] Remove old_lineup.go --- context/context.go | 8 - models/lineup_channel.go | 14 + models/old_lineup.go | 719 --------------------------------------- 3 files changed, 14 insertions(+), 727 deletions(-) delete mode 100644 models/old_lineup.go diff --git a/context/context.go b/context/context.go index 3818f5e..aed4637 100644 --- a/context/context.go +++ b/context/context.go @@ -19,7 +19,6 @@ import ( type CContext struct { API *models.APICollection Ctx ctx.Context - Lineup *models.Lineup Log *logrus.Logger Tuners map[int]chan bool GuideSourceProviders map[int]guide_providers.GuideProvider @@ -33,7 +32,6 @@ func (cc *CContext) Copy() *CContext { return &CContext{ API: cc.API, Ctx: cc.Ctx, - Lineup: cc.Lineup, Log: cc.Log, Tuners: cc.Tuners, GuideSourceProviders: cc.GuideSourceProviders, @@ -92,12 +90,6 @@ func NewCContext() (*CContext, error) { api := models.NewAPICollection(theCtx, sql) - // lineup := models.NewLineup() - - // if scanErr := lineup.Scan(); scanErr != nil { - // log.WithError(scanErr).Panicln("Error scanning lineup!") - // } - tuners := make(map[int]chan bool) guideSources, guideSourcesErr := api.GuideSource.GetAllGuideSources(false) diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 6ae7071..7bd226c 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -1,6 +1,7 @@ package models import ( + "encoding/xml" "fmt" "time" @@ -28,6 +29,19 @@ func (db *LineupChannelDB) tableName() string { return "lineup_channel" } +// HDHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. +type HDHomeRunLineupItem struct { + XMLName xml.Name `xml:"Program" json:"-"` + AudioCodec string `xml:",omitempty" json:",omitempty"` + DRM ConvertibleBoolean `xml:",omitempty" json:",omitempty"` + Favorite ConvertibleBoolean `xml:",omitempty" json:",omitempty"` + GuideName string `xml:",omitempty" json:",omitempty"` + GuideNumber string `xml:",omitempty" json:",omitempty"` + HD ConvertibleBoolean `xml:",omitempty" json:",omitempty"` + URL string `xml:",omitempty" json:",omitempty"` + VideoCodec string `xml:",omitempty" json:",omitempty"` +} + type LineupChannel struct { ID int `db:"id"` LineupID int `db:"lineup_id"` diff --git a/models/old_lineup.go b/models/old_lineup.go deleted file mode 100644 index d5bc401..0000000 --- a/models/old_lineup.go +++ /dev/null @@ -1,719 +0,0 @@ -package models - -import ( - "encoding/xml" - "fmt" - "regexp" - "sort" - "strconv" - "strings" - "time" - - "github.com/spf13/viper" - "github.com/tellytv/go.schedulesdirect" - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/providers" - "github.com/tellytv/telly/internal/xmltv" - "github.com/tellytv/telly/utils" -) - -// var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString -// var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString -// var hdRegex = regexp.MustCompile(`hd|4k`) -// var plexXMLTVNSRegex = regexp.MustCompile(`([0-9]+)?(/[0-9]+)?[ ]*\\.[ ]*([0-9]+)?(/[0-9]+)?[ ]*\\.[ ]*([0-9]+)?(/[0-9]+)?`) -var xmlNSRegex = regexp.MustCompile(`(\d).(\d).(?:(\d)/(\d))?`) -var ddProgIDRegex = regexp.MustCompile(`(?m)(EP|SH|MV|SP)(\d{7,8}).(\d+).?(?:(\d).(\d))?`) - -// HDHomeRunLineupItem is a HDHomeRun specification compatible representation of a Track available in the lineup. -type HDHomeRunLineupItem struct { - XMLName xml.Name `xml:"Program" json:"-"` - AudioCodec string `xml:",omitempty" json:",omitempty"` - DRM ConvertibleBoolean `xml:",omitempty" json:",omitempty"` - Favorite ConvertibleBoolean `xml:",omitempty" json:",omitempty"` - GuideName string `xml:",omitempty" json:",omitempty"` - GuideNumber string `xml:",omitempty" json:",omitempty"` - HD ConvertibleBoolean `xml:",omitempty" json:",omitempty"` - URL string `xml:",omitempty" json:",omitempty"` - VideoCodec string `xml:",omitempty" json:",omitempty"` - - provider providers.Provider `xml:"-"` - ProviderChannel providers.ProviderChannel `xml:"-" json:"-"` -} - -func newHDHRItem(provider *providers.Provider, ProviderChannel *providers.ProviderChannel) HDHomeRunLineupItem { - return HDHomeRunLineupItem{ - DRM: ConvertibleBoolean(false), - GuideName: ProviderChannel.Name, - GuideNumber: strconv.Itoa(ProviderChannel.Number), - Favorite: ConvertibleBoolean(ProviderChannel.Favorite), - HD: ConvertibleBoolean(ProviderChannel.HD), - URL: fmt.Sprintf("http://%s/auto/v%d", viper.GetString("web.base-address"), ProviderChannel.Number), - provider: *provider, - ProviderChannel: *ProviderChannel, - } -} - -// Lineup contains the state of the application. -type Lineup struct { - Sources []providers.Provider - - Scanning bool - - // Stores the channel number for found channels without a number. - assignedChannelNumber int - // If true, use channel numbers found in EPG, if any, before assigning. - xmlTVChannelNumbers bool - - Channels map[int]HDHomeRunLineupItem - - sd *schedulesdirect.Client -} - -// NewLineup returns a new Lineup for the given config struct. -func NewLineup() *Lineup { - var cfgs []providers.Configuration - - if unmarshalErr := viper.UnmarshalKey("source", &cfgs); unmarshalErr != nil { - log.WithError(unmarshalErr).Panicln("Unable to unmarshal source configuration to slice of providers.Configuration, check your configuration!") - } - - if viper.GetString("iptv.playlist") != "" { - log.Warnln("Legacy --iptv.playlist argument or environment variable provided, using Custom provider with default configuration, this may fail! If so, you should use a configuration file for full flexibility.") - regexStr := ".*" - if viper.IsSet("filter.regex") { - regexStr = viper.GetString("filter.regex") - } - cfgs = append(cfgs, providers.Configuration{ - Name: "Legacy provider created using arguments/environment variables", - M3U: viper.GetString("iptv.playlist"), - Provider: "custom", - Filter: regexStr, - FilterRaw: true, - }) - } - - lineup := &Lineup{ - assignedChannelNumber: viper.GetInt("iptv.starting-channel"), - xmlTVChannelNumbers: viper.GetBool("iptv.xmltv-channels"), - Channels: make(map[int]HDHomeRunLineupItem), - } - - if viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") { - sdClient, sdClientErr := schedulesdirect.NewClient(viper.GetString("schedulesdirect.username"), viper.GetString("schedulesdirect.password")) - if sdClientErr != nil { - log.WithError(sdClientErr).Panicln("error setting up schedules direct client") - } - - lineup.sd = sdClient - } - - for _, cfg := range cfgs { - provider, providerErr := cfg.GetProvider() - if providerErr != nil { - panic(providerErr) - } - - lineup.Sources = append(lineup.Sources, provider) - } - - return lineup -} - -// Scan processes all sources. -func (l *Lineup) Scan() error { - - l.Scanning = true - - totalAddedChannels := 0 - - for _, provider := range l.Sources { - addedChannels, providerErr := l.processProvider(provider) - if providerErr != nil { - log.WithError(providerErr).Errorln("error when processing provider") - } - totalAddedChannels = totalAddedChannels + addedChannels - } - - if totalAddedChannels > 420 { - log.Panicf("telly has loaded more than 420 channels (%d) into the lineup. Plex does not deal well with more than this amount and will more than likely hang when trying to fetch channels. You must use regular expressions to filter out channels. You can also start another Telly instance.", totalAddedChannels) - } - - l.Scanning = false - - return nil -} - -func (l *Lineup) processProvider(provider providers.Provider) (int, error) { - addedChannels := 0 - m3u, channelMap, programmeMap, prepareErr := l.prepareProvider(provider) - if prepareErr != nil { - log.WithError(prepareErr).Errorln("error when preparing provider") - return 0, prepareErr - } - - if provider.Configuration().SortKey != "" { - sortKey := provider.Configuration().SortKey - sort.Slice(m3u.Tracks, func(i, j int) bool { - if _, ok := m3u.Tracks[i].Tags[sortKey]; ok { - log.Panicf("the provided sort key (%s) doesn't exist in the M3U!", sortKey) - return false - } - ii := m3u.Tracks[i].Tags[sortKey] - jj := m3u.Tracks[j].Tags[sortKey] - if provider.Configuration().SortReverse { - return ii < jj - } - return ii > jj - }) - } - - successChannels := []string{} - failedChannels := []string{} - - for _, track := range m3u.Tracks { - // First, we run the filter. - if !l.FilterTrack(provider, track) { - failedChannels = append(failedChannels, track.Name) - continue - } else { - successChannels = append(successChannels, track.Name) - } - - // Then we do the provider specific translation to a HDHomeRunLineupItem. - channel, channelErr := provider.ParseTrack(track, channelMap) - if channelErr != nil { - return addedChannels, channelErr - } - - channel, processErr := l.processProviderChannel(channel, programmeMap) - if processErr != nil { - log.WithError(processErr).Errorln("error processing track") - } else if channel == nil { - log.Infof("Channel %s was returned empty from the provider (%s)", track.Name, provider.Name()) - continue - } - addedChannels = addedChannels + 1 - - l.Channels[channel.Number] = newHDHRItem(&provider, channel) - } - - log.Debugf("These channels (%d) passed the filter and successfully parsed: %s", len(successChannels), strings.Join(successChannels, ", ")) - log.Debugf("These channels (%d) did NOT pass the filter: %s", len(failedChannels), strings.Join(failedChannels, ", ")) - - log.Infof("Loaded %d channels into the lineup from %s", addedChannels, provider.Name()) - - return addedChannels, nil -} - -func (l *Lineup) prepareProvider(provider providers.Provider) (*m3u.Playlist, map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { - cacheFiles := provider.Configuration().CacheFiles - - rawPlaylist, m3uErr := utils.GetM3U(provider.PlaylistURL(), cacheFiles) - if m3uErr != nil { - log.WithError(m3uErr).Errorln("unable to get m3u file") - return nil, nil, nil, m3uErr - } - - channelMap, programmeMap, epgErr := l.prepareEPG(provider, cacheFiles) - if epgErr != nil { - log.WithError(epgErr).Errorln("error when parsing EPG") - return nil, nil, nil, epgErr - } - - return rawPlaylist, channelMap, programmeMap, nil -} - -func (l *Lineup) processProviderChannel(channel *providers.ProviderChannel, programmeMap map[string][]xmltv.Programme) (*providers.ProviderChannel, error) { - if channel.EPGChannel != nil { - channel.EPGProgrammes = programmeMap[channel.EPGMatch] - } - - if !l.xmlTVChannelNumbers || channel.Number == 0 { - channel.Number = l.assignedChannelNumber - l.assignedChannelNumber = l.assignedChannelNumber + 1 - } - - if channel.EPGChannel != nil && channel.EPGChannel.LCN == "" { - channel.EPGChannel.LCN = strconv.Itoa(channel.Number) - } - - if channel.Logo != "" && channel.EPGChannel != nil && !containsIcon(channel.EPGChannel.Icons, channel.Logo) { - if viper.GetBool("misc.ignore-epg-icons") { - channel.EPGChannel.Icons = nil - } - channel.EPGChannel.Icons = append(channel.EPGChannel.Icons, xmltv.Icon{Source: channel.Logo}) - } - - return channel, nil -} - -func (l *Lineup) FilterTrack(provider providers.Provider, track m3u.Track) bool { - config := provider.Configuration() - if config.Filter == "" && len(config.IncludeOnly) == 0 { - return true - } - - if v, ok := track.Tags[config.IncludeOnlyTag]; len(config.IncludeOnly) > 0 && ok { - return utils.Contains(config.IncludeOnly, v) - } - - filterRegex, regexErr := regexp.Compile(config.Filter) - if regexErr != nil { - log.WithError(regexErr).Panicln("your regex is invalid") - return false - } - - if config.FilterRaw { - return filterRegex.MatchString(track.Raw) - } - - log.Debugf("track.Tags %+v", track.Tags) - - filterKey := provider.RegexKey() - if config.FilterKey != "" { - filterKey = config.FilterKey - } - - if key, ok := track.Tags[filterKey]; key != "" && !ok { - log.Warnf("the provided filter key (%s) does not exist or is blank, skipping track: %s", config.FilterKey, track.Raw) - return false - } - - log.Debugf("Checking if filter (%s) matches string %s", config.Filter, track.Tags[filterKey]) - - return filterRegex.MatchString(track.Tags[filterKey]) - -} - -func (l *Lineup) prepareEPG(provider providers.Provider, cacheFiles bool) (map[string]xmltv.Channel, map[string][]xmltv.Programme, error) { - var epg *xmltv.TV - epgChannelMap := make(map[string]xmltv.Channel) - epgProgrammeMap := make(map[string][]xmltv.Programme) - if provider.EPGURL() != "" { - var epgErr error - epg, epgErr = utils.GetXMLTV(provider.EPGURL(), cacheFiles) - if epgErr != nil { - return epgChannelMap, epgProgrammeMap, epgErr - } - - augmentWithSD := viper.IsSet("schedulesdirect.username") && viper.IsSet("schedulesdirect.password") - - sdEligible := make(map[string]xmltv.Programme) // TMSID:programme - haveAllInfo := make(map[string][]xmltv.Programme) // channel number:[]programme - - for _, channel := range epg.Channels { - epgChannelMap[channel.ID] = channel - - for _, programme := range epg.Programmes { - if programme.Channel == channel.ID { - ddProgID := "" - if augmentWithSD { - for _, epNum := range programme.EpisodeNums { - if epNum.System == "dd_progid" { - ddProgID = epNum.Value - } - } - } - if augmentWithSD == true && ddProgID != "" { - idType, uniqID, epID, _, _, extractErr := extractDDProgID(ddProgID) - if extractErr != nil { - log.WithError(extractErr).Errorln("error extracting dd_progid") - continue - } - cleanID := fmt.Sprintf("%s%s%s", idType, utils.PadNumberWithZeros(uniqID, 8), utils.PadNumberWithZeros(epID, 4)) - if len(cleanID) < 14 { - log.Warnf("found an invalid TMS ID/dd_progid, expected length of exactly 14, got %d: %s\n", len(cleanID), cleanID) - continue - } - - sdEligible[cleanID] = programme - } else { - haveAllInfo[channel.ID] = append(haveAllInfo[channel.ID], programme) - } - } - } - } - - if augmentWithSD { - tmsIDs := make([]string, 0) - - for tmsID := range sdEligible { - idType, uniqID, epID, _, _, extractErr := extractDDProgID(tmsID) - if extractErr != nil { - log.WithError(extractErr).Errorln("error extracting dd_progid") - continue - } - cleanID := fmt.Sprintf("%s%s%s", idType, utils.PadNumberWithZeros(uniqID, 8), utils.PadNumberWithZeros(epID, 4)) - if len(cleanID) < 14 { - log.Warnf("found an invalid TMS ID/dd_progid, expected length of exactly 14, got %d: %s\n", len(cleanID), cleanID) - continue - } - tmsIDs = append(tmsIDs, cleanID) - } - - log.Infof("Requesting guide data for %d programs from Schedules Direct", len(tmsIDs)) - - allResponses := make([]schedulesdirect.ProgramInfo, 0) - - artworkMap := make(map[string][]schedulesdirect.ProgramArtwork) - - chunks := utils.ChunkStringSlice(tmsIDs, 5000) - - log.Infof("Making %d requests to Schedules Direct for program information, this might take a while", len(chunks)) - - for _, chunk := range chunks { - moreInfo, moreInfoErr := l.sd.GetProgramInfo(chunk) - if moreInfoErr != nil { - log.WithError(moreInfoErr).Errorln("Error when getting more program details from Schedules Direct") - return epgChannelMap, epgProgrammeMap, moreInfoErr - } - - log.Debugf("received %d responses for chunk", len(moreInfo)) - - allResponses = append(allResponses, moreInfo...) - } - - artworkTMSIDs := make([]string, 0) - - for _, entry := range allResponses { - if entry.HasArtwork() { - artworkTMSIDs = append(artworkTMSIDs, entry.ProgramID) - } - } - - chunks = utils.ChunkStringSlice(artworkTMSIDs, 500) - - log.Infof("Making %d requests to Schedules Direct for artwork, this might take a while", len(chunks)) - - for _, chunk := range chunks { - artwork, artworkErr := l.sd.GetArtworkForProgramIDs(chunk) - if artworkErr != nil { - log.WithError(artworkErr).Errorln("Error when getting program artwork from Schedules Direct") - return epgChannelMap, epgProgrammeMap, artworkErr - } - - for _, artworks := range artwork { - if artworks.ProgramID == "" || artworks.Artwork == nil { - continue - } - artworkMap[artworks.ProgramID] = append(artworkMap[artworks.ProgramID], *artworks.Artwork...) - } - } - - log.Debugf("Got %d responses from SD", len(allResponses)) - - for _, sdResponse := range allResponses { - programme := sdEligible[sdResponse.ProgramID] - mergedProgramme := MergeSchedulesDirectAndXMLTVProgramme(&programme, sdResponse, artworkMap[sdResponse.ProgramID]) - haveAllInfo[mergedProgramme.Channel] = append(haveAllInfo[mergedProgramme.Channel], *mergedProgramme) - } - } - - for _, programmes := range haveAllInfo { - for _, programme := range programmes { - processedProgram := *provider.ProcessProgramme(programme) - hasXMLTV := false - itemType := "" - for _, epNum := range processedProgram.EpisodeNums { - if epNum.System == "dd_progid" { - idType, _, _, _, _, extractErr := extractDDProgID(epNum.Value) - if extractErr != nil { - log.WithError(extractErr).Errorln("error extracting dd_progid") - continue - } - itemType = idType - } - if epNum.System == "xmltv_ns" { - hasXMLTV = true - } - } - if (itemType == "SH" || itemType == "EP") && !hasXMLTV { - t := time.Time(processedProgram.Date) - if !t.IsZero() { - processedProgram.EpisodeNums = append(processedProgram.EpisodeNums, xmltv.EpisodeNum{System: "original-air-date", Value: t.Format("2006-01-02 15:04:05")}) - } - } - epgProgrammeMap[programme.Channel] = append(epgProgrammeMap[programme.Channel], processedProgram) - } - } - - } - - return epgChannelMap, epgProgrammeMap, nil -} - -func containsIcon(s []xmltv.Icon, e string) bool { - for _, ss := range s { - if e == ss.Source { - return true - } - } - return false -} - -func MergeSchedulesDirectAndXMLTVProgramme(programme *xmltv.Programme, sdProgram schedulesdirect.ProgramInfo, artworks []schedulesdirect.ProgramArtwork) *xmltv.Programme { - - allTitles := make([]string, 0) - - for _, title := range programme.Titles { - allTitles = append(allTitles, title.Value) - } - - for _, title := range sdProgram.Titles { - allTitles = append(allTitles, title.Title120) - } - - for _, title := range UniqueStrings(allTitles) { - programme.Titles = append(programme.Titles, xmltv.CommonElement{Value: title}) - } - - allKeywords := make([]string, 0) - - for _, keyword := range programme.Keywords { - allKeywords = append(allKeywords, keyword.Value) - } - - for _, keywords := range sdProgram.Keywords { - for _, keyword := range keywords { - allKeywords = append(allKeywords, keyword) - } - } - - for _, keyword := range UniqueStrings(allKeywords) { - programme.Keywords = append(programme.Keywords, xmltv.CommonElement{Value: keyword}) - } - - // FIXME: We should really be making sure that we passthrough languages. - allDescriptions := make([]string, 0) - - for _, description := range programme.Descriptions { - allDescriptions = append(allDescriptions, description.Value) - } - - for _, descriptions := range sdProgram.Descriptions { - for _, description := range descriptions { - if description.Description != "" { - allDescriptions = append(allDescriptions, description.Description) - } - } - } - - for _, description := range UniqueStrings(allDescriptions) { - programme.Descriptions = append(programme.Descriptions, xmltv.CommonElement{Value: description}) - } - - allRatings := make(map[string]string, 0) - - for _, rating := range programme.Ratings { - allRatings[rating.System] = rating.Value - } - - for _, rating := range sdProgram.ContentRating { - allRatings[rating.Body] = rating.Code - } - - for system, rating := range allRatings { - programme.Ratings = append(programme.Ratings, xmltv.Rating{Value: rating, System: system}) - } - - for _, artwork := range artworks { - programme.Icons = append(programme.Icons, xmltv.Icon{ - Source: getImageURL(artwork.URI), - Width: artwork.Width, - Height: artwork.Height, - }) - } - - hasXMLTVNS := false - ddProgID := "" - - for _, epNum := range programme.EpisodeNums { - if epNum.System == "xmltv_ns" { - hasXMLTVNS = true - } else if epNum.System == "dd_progid" { - ddProgID = epNum.Value - } - } - - if !hasXMLTVNS { - seasonNumber := 0 - episodeNumber := 0 - totalSeasons := 0 - totalEpisodes := 0 - numbersFilled := false - - for _, meta := range sdProgram.Metadata { - for _, metadata := range meta { - if metadata.Season > 0 { - seasonNumber = metadata.Season - 1 // SD metadata isnt 0 index - numbersFilled = true - } - if metadata.Episode > 0 { - episodeNumber = metadata.Episode - 1 - numbersFilled = true - } - if metadata.TotalEpisodes > 0 { - totalEpisodes = metadata.TotalEpisodes - numbersFilled = true - } - if metadata.TotalSeasons > 0 { - totalSeasons = metadata.TotalSeasons - numbersFilled = true - } - } - } - - if numbersFilled { - seasonNumberStr := fmt.Sprintf("%d", seasonNumber) - if totalSeasons > 0 { - seasonNumberStr = fmt.Sprintf("%d/%d", seasonNumber, totalSeasons) - } - episodeNumberStr := fmt.Sprintf("%d", episodeNumber) - if totalEpisodes > 0 { - episodeNumberStr = fmt.Sprintf("%d/%d", episodeNumber, totalEpisodes) - } - - partNumber := 0 - totalParts := 0 - - if ddProgID != "" { - var extractErr error - _, _, _, partNumber, totalParts, extractErr = extractDDProgID(ddProgID) - if extractErr != nil { - panic(extractErr) - } - } - - partStr := "0" - if partNumber > 0 { - partStr = fmt.Sprintf("%d", partNumber) - if totalParts > 0 { - partStr = fmt.Sprintf("%d/%d", partNumber, totalParts) - } - } - - xmlTVNS := fmt.Sprintf("%s.%s.%s", seasonNumberStr, episodeNumberStr, partStr) - programme.EpisodeNums = append(programme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmlTVNS}) - } - } - - return programme -} - -func extractXMLTVNS(str string) (int, int, int, int, error) { - matches := xmlNSRegex.FindAllStringSubmatch(str, -1) - - if len(matches) == 0 { - return 0, 0, 0, 0, fmt.Errorf("invalid xmltv_ns: %s", str) - } - - season, seasonErr := strconv.Atoi(matches[0][1]) - if seasonErr != nil { - return 0, 0, 0, 0, seasonErr - } - - episode, episodeErr := strconv.Atoi(matches[0][2]) - if episodeErr != nil { - return 0, 0, 0, 0, episodeErr - } - - currentPartNum := 0 - totalPartsNum := 0 - - if len(matches[0]) > 2 && matches[0][3] != "" { - currentPart, currentPartErr := strconv.Atoi(matches[0][3]) - if currentPartErr != nil { - return 0, 0, 0, 0, currentPartErr - } - currentPartNum = currentPart - } - - if len(matches[0]) > 3 && matches[0][4] != "" { - totalParts, totalPartsErr := strconv.Atoi(matches[0][4]) - if totalPartsErr != nil { - return 0, 0, 0, 0, totalPartsErr - } - totalPartsNum = totalParts - } - - // if season > 0 { - // season = season - 1 - // } - - // if episode > 0 { - // episode = episode - 1 - // } - - // if currentPartNum > 0 { - // currentPartNum = currentPartNum - 1 - // } - - // if totalPartsNum > 0 { - // totalPartsNum = totalPartsNum - 1 - // } - - return season, episode, currentPartNum, totalPartsNum, nil -} - -// extractDDProgID returns type, ID, episode ID, part number, total parts, error. -func extractDDProgID(progID string) (string, int, int, int, int, error) { - matches := ddProgIDRegex.FindAllStringSubmatch(progID, -1) - - if len(matches) == 0 { - return "", 0, 0, 0, 0, fmt.Errorf("invalid dd_progid: %s", progID) - } - - itemType := matches[0][1] - - itemID, itemIDErr := strconv.Atoi(matches[0][2]) - if itemIDErr != nil { - return itemType, 0, 0, 0, 0, itemIDErr - } - - specificID, specificIDErr := strconv.Atoi(matches[0][3]) - if specificIDErr != nil { - return itemType, itemID, 0, 0, 0, specificIDErr - } - - currentPartNum := 0 - totalPartsNum := 0 - - if len(matches[0]) > 2 && matches[0][4] != "" { - currentPart, currentPartErr := strconv.Atoi(matches[0][4]) - if currentPartErr != nil { - return itemType, itemID, specificID, 0, 0, currentPartErr - } - currentPartNum = currentPart - } - - if len(matches[0]) > 3 && matches[0][5] != "" { - totalParts, totalPartsErr := strconv.Atoi(matches[0][5]) - if totalPartsErr != nil { - return itemType, itemID, specificID, currentPartNum, 0, totalPartsErr - } - totalPartsNum = totalParts - } - - return itemType, itemID, specificID, currentPartNum, totalPartsNum, nil -} - -func UniqueStrings(input []string) []string { - u := make([]string, 0, len(input)) - m := make(map[string]bool) - - for _, val := range input { - if _, ok := m[val]; !ok { - m[val] = true - u = append(u, val) - } - } - - return u -} - -func getImageURL(imageURI string) string { - if strings.HasPrefix(imageURI, "https://s3.amazonaws.com") { - return imageURI - } - return fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", imageURI) -} From 69b30a23eb76be3cc89e39729629f45422ef07af Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 01:38:13 -0700 Subject: [PATCH 072/182] Remove SQLLineup to Lineup --- api/lineup.go | 4 ++-- api/lineup_channel.go | 7 +++---- api/tuner.go | 10 +++++----- api/utils.go | 4 ++-- models/lineup.go | 34 +++++++++++++++++----------------- models/lineup_channel.go | 2 +- 6 files changed, 30 insertions(+), 31 deletions(-) diff --git a/api/lineup.go b/api/lineup.go index 7cf65db..d58b417 100644 --- a/api/lineup.go +++ b/api/lineup.go @@ -10,7 +10,7 @@ import ( ) func addLineup(cc *context.CContext, c *gin.Context) { - var payload models.SQLLineup + var payload models.Lineup if c.BindJSON(&payload) == nil { newLineup, lineupErr := cc.API.Lineup.InsertLineup(payload) if lineupErr != nil { @@ -36,7 +36,7 @@ func getLineups(cc *context.CContext, c *gin.Context) { c.JSON(http.StatusOK, allLineups) } -func lineupRoute(cc *context.CContext, originalFunc func(*models.SQLLineup, *context.CContext, *gin.Context)) gin.HandlerFunc { +func lineupRoute(cc *context.CContext, originalFunc func(*models.Lineup, *context.CContext, *gin.Context)) gin.HandlerFunc { return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { lineupID, lineupIDErr := strconv.Atoi(c.Param("lineupId")) if lineupIDErr != nil { diff --git a/api/lineup_channel.go b/api/lineup_channel.go index 1d4a92f..f08a3c3 100644 --- a/api/lineup_channel.go +++ b/api/lineup_channel.go @@ -8,11 +8,11 @@ import ( "github.com/tellytv/telly/models" ) -func getLineup(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { +func getLineup(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { c.JSON(http.StatusOK, lineup) } -func addLineupChannel(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { +func addLineupChannel(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { var payload models.LineupChannel if c.BindJSON(&payload) == nil { payload.LineupID = lineup.ID @@ -28,7 +28,7 @@ func addLineupChannel(lineup *models.SQLLineup, cc *context.CContext, c *gin.Con } } -func updateLineupChannels(lineup *models.SQLLineup, cc *context.CContext, c *gin.Context) { +func updateLineupChannels(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { newChannels := make([]models.LineupChannel, 0) if c.BindJSON(&newChannels) == nil { for idx, channel := range newChannels { @@ -36,7 +36,6 @@ func updateLineupChannels(lineup *models.SQLLineup, cc *context.CContext, c *gin channel.GuideChannel = nil channel.HDHR = nil channel.VideoTrack = nil - log.Infof("GOT CHANNEL %+v", channel) newChannel, lineupErr := cc.API.LineupChannel.UpsertLineupChannel(channel) if lineupErr != nil { c.AbortWithError(http.StatusInternalServerError, lineupErr) diff --git a/api/tuner.go b/api/tuner.go index 520c8cc..e64c669 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -22,7 +22,7 @@ import ( "github.com/tellytv/telly/models" ) -func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.SQLLineup) { +func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { channels, channelsErr := cc.API.LineupChannel.GetChannelsForLineup(lineup.ID, true) if channelsErr != nil { log.WithError(channelsErr).Errorln("error getting channels in lineup") @@ -184,7 +184,7 @@ func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { } } -func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { +func stream(cc *ccontext.CContext, lineup *models.Lineup) gin.HandlerFunc { return func(c *gin.Context) { channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(lineup.ID, c.Param("channelNumber")[1:]) if channelErr != nil { @@ -269,7 +269,7 @@ func stream(cc *ccontext.CContext, lineup *models.SQLLineup) gin.HandlerFunc { } } -func scanChannels(lineup *models.SQLLineup) gin.HandlerFunc { +func scanChannels(lineup *models.Lineup) gin.HandlerFunc { return func(c *gin.Context) { scanAction := c.Query("scan") if scanAction == "start" { @@ -287,7 +287,7 @@ func scanChannels(lineup *models.SQLLineup) gin.HandlerFunc { } } -func lineupStatus(lineup *models.SQLLineup) gin.HandlerFunc { +func lineupStatus(lineup *models.Lineup) gin.HandlerFunc { return func(c *gin.Context) { payload := LineupStatus{ ScanInProgress: models.ConvertibleBoolean(false), @@ -295,7 +295,7 @@ func lineupStatus(lineup *models.SQLLineup) gin.HandlerFunc { Source: "Cable", SourceList: []string{"Cable"}, } - // FIXME: Implement a scan param on SQLLineup. + // FIXME: Implement a scan param on Lineup. if false { payload = LineupStatus{ ScanInProgress: models.ConvertibleBoolean(true), diff --git a/api/utils.go b/api/utils.go index 897a11a..75565cc 100644 --- a/api/utils.go +++ b/api/utils.go @@ -113,14 +113,14 @@ func newGin() *gin.Engine { return router } -func StartTuner(cc *context.CContext, lineup *models.SQLLineup) { +func StartTuner(cc *context.CContext, lineup *models.Lineup) { tunerChan := make(chan bool) cc.Tuners[lineup.ID] = tunerChan go ServeLineup(cc, tunerChan, lineup) return } -func RestartTuner(cc *context.CContext, lineup *models.SQLLineup) { +func RestartTuner(cc *context.CContext, lineup *models.Lineup) { if tuner, ok := cc.Tuners[lineup.ID]; ok { tuner <- true } diff --git a/models/lineup.go b/models/lineup.go index ecfe994..dcd4ef2 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -68,7 +68,7 @@ func (d *DiscoveryData) UPNP() upnp.RootDevice { } } -type SQLLineup struct { +type Lineup struct { ID int `db:"id"` Name string `db:"name"` SSDP bool `db:"ssdp"` @@ -89,7 +89,7 @@ type SQLLineup struct { Channels []LineupChannel } -func (s *SQLLineup) GetDiscoveryData() DiscoveryData { +func (s *Lineup) GetDiscoveryData() DiscoveryData { baseAddr := fmt.Sprintf("http://%s:%d", s.DiscoveryAddress, s.Port) return DiscoveryData{ FriendlyName: s.Name, @@ -109,11 +109,11 @@ func (s *SQLLineup) GetDiscoveryData() DiscoveryData { // LineupAPI contains all methods for the User struct type LineupAPI interface { - InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) - DeleteLineup(lineupID int) (*SQLLineup, error) - UpdateLineup(lineupID int, description string) (*SQLLineup, error) - GetLineupByID(id int, withChannels bool) (*SQLLineup, error) - GetEnabledLineups(withChannels bool) ([]SQLLineup, error) + InsertLineup(lineupStruct Lineup) (*Lineup, error) + DeleteLineup(lineupID int) (*Lineup, error) + UpdateLineup(lineupID int, description string) (*Lineup, error) + GetLineupByID(id int, withChannels bool) (*Lineup, error) + GetEnabledLineups(withChannels bool) ([]Lineup, error) } const baseLineupQuery string = ` @@ -137,8 +137,8 @@ SELECT FROM lineup L` // InsertLineup inserts a new Lineup into the database. -func (db *LineupDB) InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) { - lineup := SQLLineup{} +func (db *LineupDB) InsertLineup(lineupStruct Lineup) (*Lineup, error) { + lineup := Lineup{} res, err := db.SQL.NamedExec(` INSERT INTO lineup (name, ssdp, listen_address, discovery_address, port, tuners, manufacturer, model_name, model_number, firmware_name, firmware_version, device_id, device_auth, device_uuid) VALUES (:name, :ssdp, :listen_address, :discovery_address, :port, :tuners, :manufacturer, :model_name, :model_number, :firmware_name, :firmware_version, :device_id, :device_auth, :device_uuid)`, lineupStruct) @@ -154,8 +154,8 @@ func (db *LineupDB) InsertLineup(lineupStruct SQLLineup) (*SQLLineup, error) { } // GetLineupByID returns a single Lineup for the given ID. -func (db *LineupDB) GetLineupByID(id int, withChannels bool) (*SQLLineup, error) { - var lineup SQLLineup +func (db *LineupDB) GetLineupByID(id int, withChannels bool) (*Lineup, error) { + var lineup Lineup err := db.SQL.Get(&lineup, fmt.Sprintf(`%s WHERE L.id = $1`, baseLineupQuery), id) if withChannels { channels, channelsErr := db.Collection.LineupChannel.GetChannelsForLineup(lineup.ID, true) @@ -168,22 +168,22 @@ func (db *LineupDB) GetLineupByID(id int, withChannels bool) (*SQLLineup, error) } // DeleteLineup marks a lineup with the given ID as deleted. -func (db *LineupDB) DeleteLineup(lineupID int) (*SQLLineup, error) { - lineup := SQLLineup{} +func (db *LineupDB) DeleteLineup(lineupID int) (*Lineup, error) { + lineup := Lineup{} err := db.SQL.Get(&lineup, `DELETE FROM lineup WHERE id = $1`, lineupID) return &lineup, err } // UpdateLineup updates a lineup. -func (db *LineupDB) UpdateLineup(lineupID int, description string) (*SQLLineup, error) { - lineup := SQLLineup{} +func (db *LineupDB) UpdateLineup(lineupID int, description string) (*Lineup, error) { + lineup := Lineup{} err := db.SQL.Get(&lineup, `UPDATE lineup SET description = $2 WHERE id = $1 RETURNING *`, lineupID, description) return &lineup, err } // GetEnabledLineups returns all enabled lineups in the database. -func (db *LineupDB) GetEnabledLineups(withChannels bool) ([]SQLLineup, error) { - lineups := make([]SQLLineup, 0) +func (db *LineupDB) GetEnabledLineups(withChannels bool) ([]Lineup, error) { + lineups := make([]Lineup, 0) err := db.SQL.Select(&lineups, baseLineupQuery) if withChannels { for idx, lineup := range lineups { diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 7bd226c..0c261f0 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -57,7 +57,7 @@ type LineupChannel struct { GuideChannel *GuideSourceChannel `json:",omitempty"` HDHR *HDHomeRunLineupItem `json:",omitempty"` - lineup *SQLLineup + lineup *Lineup } func (l *LineupChannel) String() string { From c0219d9b2233abf0d0d8ccd8c39fee51242369d7 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 01:40:24 -0700 Subject: [PATCH 073/182] Remove providers package --- internal/providers/area51.go | 81 ------------------ internal/providers/custom.go | 89 ------------------- internal/providers/eternal.go | 4 - internal/providers/hellraiser.go | 4 - internal/providers/iptv-epg.go | 92 -------------------- internal/providers/iris.go | 81 ------------------ internal/providers/main.go | 95 --------------------- internal/providers/tnt.go | 4 - internal/providers/vaders.go | 141 ------------------------------- 9 files changed, 591 deletions(-) delete mode 100644 internal/providers/area51.go delete mode 100644 internal/providers/custom.go delete mode 100644 internal/providers/eternal.go delete mode 100644 internal/providers/hellraiser.go delete mode 100644 internal/providers/iptv-epg.go delete mode 100644 internal/providers/iris.go delete mode 100644 internal/providers/main.go delete mode 100644 internal/providers/tnt.go delete mode 100644 internal/providers/vaders.go diff --git a/internal/providers/area51.go b/internal/providers/area51.go deleted file mode 100644 index e2c2f87..0000000 --- a/internal/providers/area51.go +++ /dev/null @@ -1,81 +0,0 @@ -package providers - -import ( - "fmt" - "strings" - - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/xmltv" -) - -// http://iptv-area-51.tv:2095/get.php?username=username&password=password&type=m3uplus&output=ts -// http://iptv-area-51.tv:2095/xmltv.php?username=username&password=password - -type area51 struct { - BaseConfig Configuration -} - -func newArea51(config *Configuration) (Provider, error) { - return &area51{*config}, nil -} - -func (i *area51) Name() string { - return "Area51" -} - -func (i *area51) PlaylistURL() string { - return fmt.Sprintf("http://iptv-area-51.tv:2095/get.php?username=%s&password=%s&type=m3u_plus&output=ts", i.BaseConfig.Username, i.BaseConfig.Password) -} - -func (i *area51) EPGURL() string { - return fmt.Sprintf("http://iptv-area-51.tv:2095/xmltv.php?username=%s&password=%s", i.BaseConfig.Username, i.BaseConfig.Password) -} - -// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. -func (i *area51) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { - nameVal := track.Name - if i.BaseConfig.NameKey != "" { - nameVal = track.Tags[i.BaseConfig.NameKey] - } - - logoVal := track.Tags["tvg-logo"] - if i.BaseConfig.LogoKey != "" { - logoVal = track.Tags[i.BaseConfig.LogoKey] - } - - pChannel := &ProviderChannel{ - Name: nameVal, - Logo: logoVal, - Number: 0, - StreamURL: track.URI, - StreamID: 0, - HD: strings.Contains(strings.ToLower(track.Name), "hd"), - StreamFormat: "Unknown", - Track: track, - OnDemand: false, - } - - epgVal := track.Tags["tvg-id"] - if i.BaseConfig.EPGMatchKey != "" { - epgVal = track.Tags[i.BaseConfig.EPGMatchKey] - } - - if xmlChan, ok := channelMap[epgVal]; ok { - pChannel.EPGMatch = epgVal - pChannel.EPGChannel = &xmlChan - } - - return pChannel, nil -} - -func (i *area51) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { - return &programme -} - -func (i *area51) Configuration() Configuration { - return i.BaseConfig -} - -func (i *area51) RegexKey() string { - return "group-title" -} diff --git a/internal/providers/custom.go b/internal/providers/custom.go deleted file mode 100644 index 721ddc9..0000000 --- a/internal/providers/custom.go +++ /dev/null @@ -1,89 +0,0 @@ -package providers - -import ( - "strconv" - "strings" - - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/xmltv" -) - -type customProvider struct { - BaseConfig Configuration -} - -func newCustomProvider(config *Configuration) (Provider, error) { - return &customProvider{*config}, nil -} - -func (i *customProvider) Name() string { - return i.BaseConfig.Name -} - -func (i *customProvider) PlaylistURL() string { - return i.BaseConfig.M3U -} - -func (i *customProvider) EPGURL() string { - return i.BaseConfig.EPG -} - -// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. -func (i *customProvider) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { - channelVal := track.Tags["tvg-chno"] - if i.BaseConfig.ChannelNumberKey != "" { - channelVal = track.Tags[i.BaseConfig.ChannelNumberKey] - } - - chanNum := 0 - - if channelNumber, channelNumberErr := strconv.Atoi(channelVal); channelNumberErr == nil { - chanNum = channelNumber - } - - nameVal := track.Name - if i.BaseConfig.NameKey != "" { - nameVal = track.Tags[i.BaseConfig.NameKey] - } - - logoVal := track.Tags["tvg-logo"] - if i.BaseConfig.LogoKey != "" { - logoVal = track.Tags[i.BaseConfig.LogoKey] - } - - pChannel := &ProviderChannel{ - Name: nameVal, - Logo: logoVal, - Number: chanNum, - StreamURL: track.URI, - StreamID: chanNum, - HD: strings.Contains(strings.ToLower(track.Name), "hd"), - StreamFormat: "Unknown", - Track: track, - OnDemand: false, - } - - epgVal := track.Tags["tvg-id"] - if i.BaseConfig.EPGMatchKey != "" { - epgVal = track.Tags[i.BaseConfig.EPGMatchKey] - } - - if xmlChan, ok := channelMap[epgVal]; ok { - pChannel.EPGMatch = epgVal - pChannel.EPGChannel = &xmlChan - } - - return pChannel, nil -} - -func (i *customProvider) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { - return &programme -} - -func (i *customProvider) Configuration() Configuration { - return i.BaseConfig -} - -func (i *customProvider) RegexKey() string { - return i.BaseConfig.FilterKey -} diff --git a/internal/providers/eternal.go b/internal/providers/eternal.go deleted file mode 100644 index d307eb4..0000000 --- a/internal/providers/eternal.go +++ /dev/null @@ -1,4 +0,0 @@ -package providers - -// M3U: http://live.eternaltv.net:25461/get.php?username=xxxxxxx&password=xxxxxx&output=ts&type=m3uplus -// XMLTV: http://live.eternaltv.net:25461/xmltv.php?username=xxxxx&password=xxxxx&type=m3uplus&output=ts diff --git a/internal/providers/hellraiser.go b/internal/providers/hellraiser.go deleted file mode 100644 index 0608474..0000000 --- a/internal/providers/hellraiser.go +++ /dev/null @@ -1,4 +0,0 @@ -package providers - -// Playlist URL: http://liquidit.info:8080/get.php?username=xxxx&password=xxxxxxx&type=m3uplus&output=ts -// XMLTV URL: http://liquidit.info:8080/xmltv.php?username=xxxxxx&password=xxxxxx diff --git a/internal/providers/iptv-epg.go b/internal/providers/iptv-epg.go deleted file mode 100644 index 258239b..0000000 --- a/internal/providers/iptv-epg.go +++ /dev/null @@ -1,92 +0,0 @@ -package providers - -import ( - "fmt" - "strconv" - "strings" - - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/xmltv" -) - -// M3U: http://iptv-epg.com/.m3u -// XMLTV: http://iptv-epg.com/.xml - -type iptvepg struct { - BaseConfig Configuration -} - -func newIPTVEPG(config *Configuration) (Provider, error) { - return &iptvepg{*config}, nil -} - -func (i *iptvepg) Name() string { - return "IPTV-EPG" -} - -func (i *iptvepg) PlaylistURL() string { - return fmt.Sprintf("http://iptv-epg.com/%s.m3u", i.BaseConfig.Username) -} - -func (i *iptvepg) EPGURL() string { - return fmt.Sprintf("http://iptv-epg.com/%s.xml", i.BaseConfig.Password) -} - -// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. -func (i *iptvepg) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { - channelVal := track.Tags["tvg-chno"] - if i.BaseConfig.ChannelNumberKey != "" { - channelVal = track.Tags[i.BaseConfig.ChannelNumberKey] - } - - channelNumber, channelNumberErr := strconv.Atoi(channelVal) - if channelNumberErr != nil { - return nil, channelNumberErr - } - - nameVal := track.Name - if i.BaseConfig.NameKey != "" { - nameVal = track.Tags[i.BaseConfig.NameKey] - } - - logoVal := track.Tags["tvg-logo"] - if i.BaseConfig.LogoKey != "" { - logoVal = track.Tags[i.BaseConfig.LogoKey] - } - - pChannel := &ProviderChannel{ - Name: nameVal, - Logo: logoVal, - Number: channelNumber, - StreamURL: track.URI, - StreamID: channelNumber, - HD: strings.Contains(strings.ToLower(track.Name), "hd"), - StreamFormat: "Unknown", - Track: track, - OnDemand: false, - } - - epgVal := track.Tags["tvg-id"] - if i.BaseConfig.EPGMatchKey != "" { - epgVal = track.Tags[i.BaseConfig.EPGMatchKey] - } - - if xmlChan, ok := channelMap[epgVal]; ok { - pChannel.EPGMatch = epgVal - pChannel.EPGChannel = &xmlChan - } - - return pChannel, nil -} - -func (i *iptvepg) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { - return &programme -} - -func (i *iptvepg) Configuration() Configuration { - return i.BaseConfig -} - -func (i *iptvepg) RegexKey() string { - return "group-title" -} diff --git a/internal/providers/iris.go b/internal/providers/iris.go deleted file mode 100644 index c05814a..0000000 --- a/internal/providers/iris.go +++ /dev/null @@ -1,81 +0,0 @@ -package providers - -import ( - "fmt" - "strings" - - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/xmltv" -) - -// http://irislinks.net:83/get.php?username=username&password=password&type=m3uplus&output=ts -// http://irislinks.net:83/xmltv.php?username=username&password=password - -type iris struct { - BaseConfig Configuration -} - -func newIris(config *Configuration) (Provider, error) { - return &iris{*config}, nil -} - -func (i *iris) Name() string { - return "Iris" -} - -func (i *iris) PlaylistURL() string { - return fmt.Sprintf("http://irislinks.net:83/get.php?username=%s&password=%s&type=m3u_plus&output=ts", i.BaseConfig.Username, i.BaseConfig.Password) -} - -func (i *iris) EPGURL() string { - return fmt.Sprintf("http://irislinks.net:83/xmltv.php?username=%s&password=%s", i.BaseConfig.Username, i.BaseConfig.Password) -} - -// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. -func (i *iris) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { - nameVal := track.Name - if i.BaseConfig.NameKey != "" { - nameVal = track.Tags[i.BaseConfig.NameKey] - } - - logoVal := track.Tags["tvg-logo"] - if i.BaseConfig.LogoKey != "" { - logoVal = track.Tags[i.BaseConfig.LogoKey] - } - - pChannel := &ProviderChannel{ - Name: nameVal, - Logo: logoVal, - Number: 0, - StreamURL: track.URI, - StreamID: 0, - HD: strings.Contains(strings.ToLower(track.Name), "hd"), - StreamFormat: "Unknown", - Track: track, - OnDemand: false, - } - - epgVal := track.Tags["tvg-id"] - if i.BaseConfig.EPGMatchKey != "" { - epgVal = track.Tags[i.BaseConfig.EPGMatchKey] - } - - if xmlChan, ok := channelMap[epgVal]; ok { - pChannel.EPGMatch = epgVal - pChannel.EPGChannel = &xmlChan - } - - return pChannel, nil -} - -func (i *iris) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { - return &programme -} - -func (i *iris) Configuration() Configuration { - return i.BaseConfig -} - -func (i *iris) RegexKey() string { - return "group-title" -} diff --git a/internal/providers/main.go b/internal/providers/main.go deleted file mode 100644 index 76e8b83..0000000 --- a/internal/providers/main.go +++ /dev/null @@ -1,95 +0,0 @@ -package providers - -import ( - "regexp" - "strings" - - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/xmltv" -) - -var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch -var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString -var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString -var hdRegex = regexp.MustCompile(`hd|4k`) - -type Configuration struct { - Name string `json:"-"` - Provider string - - Username string `json:"username"` - Password string `json:"password"` - - M3U string `json:"-"` - EPG string `json:"-"` - - VideoOnDemand bool `json:"-"` - - Filter string - FilterKey string - FilterRaw bool - - SortKey string - SortReverse bool - - Favorites []string - FavoriteTag string - - IncludeOnly []string - IncludeOnlyTag string - - CacheFiles bool - - NameKey string - LogoKey string - ChannelNumberKey string - EPGMatchKey string -} - -func (i *Configuration) GetProvider() (Provider, error) { - switch strings.ToLower(i.Provider) { - case "vaders": - return newVaders(i) - case "iptv-epg", "iptvepg": - return newIPTVEPG(i) - case "iris", "iristv": - return newIris(i) - case "area51": - return newArea51(i) - default: - return newCustomProvider(i) - } -} - -// ProviderChannel describes a channel available in the providers lineup with necessary pieces parsed into fields. -type ProviderChannel struct { - Name string - StreamID int // Should be the integer just before .ts. - Number int - Logo string - StreamURL string - HD bool - Quality string - OnDemand bool - StreamFormat string - Favorite bool - - EPGMatch string - EPGChannel *xmltv.Channel - EPGProgrammes []xmltv.Programme - Track m3u.Track -} - -// Provider describes a IPTV provider configuration. -type Provider interface { - Name() string - PlaylistURL() string - EPGURL() string - - // These are functions to extract information from playlists. - ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) - ProcessProgramme(programme xmltv.Programme) *xmltv.Programme - - RegexKey() string - Configuration() Configuration -} diff --git a/internal/providers/tnt.go b/internal/providers/tnt.go deleted file mode 100644 index 3960706..0000000 --- a/internal/providers/tnt.go +++ /dev/null @@ -1,4 +0,0 @@ -package providers - -// M3U: http://thesepeanutz.xyz:2052/get.php?username=xxx&password=xxx&type=m3uplus&output=ts -// XMLTV: http://thesepeanutz.xyz:2052/xmltv.php?username=xxx&password=xxx diff --git a/internal/providers/vaders.go b/internal/providers/vaders.go deleted file mode 100644 index a4e85a8..0000000 --- a/internal/providers/vaders.go +++ /dev/null @@ -1,141 +0,0 @@ -package providers - -import ( - "encoding/base64" - "encoding/json" - "fmt" - "regexp" - "strconv" - "strings" - - log "github.com/sirupsen/logrus" - m3u "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/internal/xmltv" - "github.com/tellytv/telly/utils" -) - -// This regex matches and extracts the following URLs. -// http://vapi.vaders.tv/play/dvr/${start}/123.ts?duration=3600&token= -// http://vapi.vaders.tv/play/123.ts?token= -// http://vapi.vaders.tv/play/vod/123.mp4.m3u8?token= -// http://vapi.vaders.tv/play/vod/123.avi.m3u8?token= -// http://vapi.vaders.tv/play/vod/123.mkv.m3u8?token= -var vadersURL = regexp.MustCompile(`/(vod/|dvr/\${start}/)?(\d+).(ts|.*.m3u8)\?(duration=\d+&)?token=`).FindAllStringSubmatch - -// M3U: http://api.vaders.tv/vget?username=xxx&password=xxx&format=ts -// XMLTV: http://vaders.tv/p2.xml - -type vader struct { - BaseConfig Configuration - - Token string `json:"-"` -} - -func newVaders(config *Configuration) (Provider, error) { - tok, tokErr := json.Marshal(config) - if tokErr != nil { - return nil, tokErr - } - - return &vader{*config, base64.StdEncoding.EncodeToString(tok)}, nil -} - -func (v *vader) Name() string { - return "Vaders.tv" -} - -func (v *vader) PlaylistURL() string { - return fmt.Sprintf("http://api.vaders.tv/vget?username=%s&password=%s&vod=%t&format=ts", v.BaseConfig.Username, v.BaseConfig.Password, v.BaseConfig.VideoOnDemand) -} - -func (v *vader) EPGURL() string { - return "http://vaders.tv/p2.xml.gz" -} - -// ParseTrack matches the provided M3U track an XMLTV channel and returns a ProviderChannel. -func (v *vader) ParseTrack(track m3u.Track, channelMap map[string]xmltv.Channel) (*ProviderChannel, error) { - streamURL := vadersURL(track.URI, -1)[0] - - vod := strings.Contains(streamURL[1], "vod") - - if v.BaseConfig.VideoOnDemand == false && vod { - return nil, nil - } - - channelID, channelIDErr := strconv.Atoi(streamURL[2]) - if channelIDErr != nil { - return nil, channelIDErr - } - - nameVal := track.Tags["tvg-name"] - if v.BaseConfig.NameKey != "" { - nameVal = track.Tags[v.BaseConfig.NameKey] - } - - logoVal := track.Tags["tvg-logo"] - if v.BaseConfig.LogoKey != "" { - logoVal = track.Tags[v.BaseConfig.LogoKey] - } - - pChannel := &ProviderChannel{ - Name: nameVal, - Logo: logoVal, - StreamURL: track.URI, - StreamID: channelID, - HD: strings.Contains(strings.ToLower(track.Tags["tvg-name"]), "hd"), - StreamFormat: streamURL[3], - Track: track, - OnDemand: vod, - } - - if xmlChan, ok := channelMap[track.Tags["tvg-id"]]; ok { - pChannel.EPGMatch = track.Tags["tvg-id"] - pChannel.EPGChannel = &xmlChan - - for _, displayName := range xmlChan.DisplayNames { - if channelNumberRegex(displayName.Value) { - if chanNum, chanNumErr := strconv.Atoi(displayName.Value); chanNumErr == nil { - pChannel.Number = chanNum - } - } - } - } - - favoriteTag := "tvg-id" - - if v.BaseConfig.FavoriteTag != "" { - favoriteTag = v.BaseConfig.FavoriteTag - } - - if _, ok := track.Tags[favoriteTag]; !ok { - log.Panicf("The specified favorite tag (%s) doesn't exist on the track with URL %s", favoriteTag, track.URI) - return nil, nil - } - - pChannel.Favorite = utils.Contains(v.BaseConfig.Favorites, track.Tags[favoriteTag]) - - return pChannel, nil -} - -func (v *vader) ProcessProgramme(programme xmltv.Programme) *xmltv.Programme { - isNew := false - for idx, title := range programme.Titles { - isNew = strings.HasSuffix(title.Value, " [New!]") - programme.Titles[idx].Value = strings.Replace(title.Value, " [New!]", "", -1) - } - - if isNew { - elm := xmltv.ElementPresent(true) - programme.New = &elm - } - - return &programme -} - -func (v *vader) Configuration() Configuration { - return v.BaseConfig -} - -func (v *vader) RegexKey() string { - return "group-title" -} From bfeda9f8c2cd2a656e2d7cc1a8078a6da04d55cb Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 02:20:25 -0700 Subject: [PATCH 074/182] quick passthrough with gometalinter --- api/main.go | 1 + api/tuner.go | 26 ++++++++++--------- api/utils.go | 2 ++ api/xmltv.go | 6 ++--- context/context.go | 14 +++++----- .../main.go | 7 +++-- .../schedules_direct.go | 14 +++++++--- .../xmltv.go | 8 +++++- .../m3u.go | 14 +++++++--- .../main.go | 15 ++++------- .../xtream.go | 12 ++++++++- internal/xmltv/xmltv.go | 17 +++++++----- metrics/metrics.go | 2 ++ models/guide_source.go | 8 +++--- models/guide_source_channel.go | 7 ++--- models/guide_source_programme.go | 1 + models/lineup.go | 2 ++ models/lineup_channel.go | 3 +++ models/types.go | 3 +++ models/video_source.go | 8 +++--- models/video_source_track.go | 1 + utils/main.go | 21 +++++++++++---- 22 files changed, 129 insertions(+), 63 deletions(-) rename internal/{guide_providers => guideproviders}/main.go (83%) rename internal/{guide_providers => guideproviders}/schedules_direct.go (96%) rename internal/{guide_providers => guideproviders}/xmltv.go (80%) rename internal/{video_providers => videoproviders}/m3u.go (82%) rename internal/{video_providers => videoproviders}/main.go (85%) rename internal/{video_providers => videoproviders}/xtream.go (76%) diff --git a/api/main.go b/api/main.go index b5ca707..e1ebcaa 100644 --- a/api/main.go +++ b/api/main.go @@ -24,6 +24,7 @@ var ( prom = ginprometheus.NewPrometheus("http") ) +// ServeAPI starts up the telly frontend + REST API. func ServeAPI(cc *context.CContext) { log.Debugln("creating webserver routes") diff --git a/api/tuner.go b/api/tuner.go index e64c669..25c5b5d 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -4,6 +4,7 @@ import ( "bufio" "bytes" "context" + "database/sql" "encoding/xml" "fmt" "io" @@ -22,6 +23,7 @@ import ( "github.com/tellytv/telly/models" ) +// ServeLineup starts up a server dedicated to a single Lineup. func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { channels, channelsErr := cc.API.LineupChannel.GetChannelsForLineup(lineup.ID, true) if channelsErr != nil { @@ -188,26 +190,30 @@ func stream(cc *ccontext.CContext, lineup *models.Lineup) gin.HandlerFunc { return func(c *gin.Context) { channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(lineup.ID, c.Param("channelNumber")[1:]) if channelErr != nil { + if channelErr == sql.ErrNoRows { + c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %s", channel.ChannelNumber)) + return + } c.AbortWithError(http.StatusInternalServerError, channelErr) return } log.Infoln("Serving", channel) - streamUrl, streamUrlErr := cc.VideoSourceProviders[channel.VideoTrack.VideoSourceID].StreamURL(channel.VideoTrack.StreamID, "ts") - if streamUrlErr != nil { - c.AbortWithError(http.StatusInternalServerError, streamUrlErr) + streamURL, streamURLErr := cc.VideoSourceProviders[channel.VideoTrack.VideoSourceID].StreamURL(channel.VideoTrack.StreamID, "ts") + if streamURLErr != nil { + c.AbortWithError(http.StatusInternalServerError, streamURLErr) return } if !viper.IsSet("iptv.ffmpeg") { - c.Redirect(http.StatusMovedPermanently, streamUrl) + c.Redirect(http.StatusMovedPermanently, streamURL) return } log.Infoln("Transcoding stream with ffmpeg") - run := exec.Command("ffmpeg", "-re", "-i", streamUrl, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "-progress", "pipe:2", "pipe:1") + run := exec.Command("ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "-progress", "pipe:2", "pipe:1") ffmpegout, err := run.StdoutPipe() if err != nil { log.WithError(err).Errorln("StdoutPipe Error") @@ -262,10 +268,6 @@ func stream(cc *ccontext.CContext, lineup *models.Lineup) gin.HandlerFunc { } c.Stream(streamVideo) - - return - - c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %d", channel.ChannelNumber)) } } @@ -328,7 +330,7 @@ func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error return 0, nil, nil } -type FFMPEGStatus struct { +type ffMPEGStatus struct { FramesProcessed string CurrentTime string CurrentBitrate string @@ -336,8 +338,8 @@ type FFMPEGStatus struct { Speed string } -func processFFMPEGStatus(line string) *FFMPEGStatus { - status := new(FFMPEGStatus) +func processFFMPEGStatus(line string) *ffMPEGStatus { + status := new(ffMPEGStatus) if strings.Contains(line, "frame=") && strings.Contains(line, "time=") && strings.Contains(line, "bitrate=") { var re = regexp.MustCompile(`=\s+`) st := re.ReplaceAllString(line, `=`) diff --git a/api/utils.go b/api/utils.go index 75565cc..2d68f25 100644 --- a/api/utils.go +++ b/api/utils.go @@ -113,6 +113,7 @@ func newGin() *gin.Engine { return router } +// StartTuner will start a new tuner server for the given lineup. func StartTuner(cc *context.CContext, lineup *models.Lineup) { tunerChan := make(chan bool) cc.Tuners[lineup.ID] = tunerChan @@ -120,6 +121,7 @@ func StartTuner(cc *context.CContext, lineup *models.Lineup) { return } +// RestartTuner will trigger a restart of the tuner server for the given lineup. func RestartTuner(cc *context.CContext, lineup *models.Lineup) { if tuner, ok := cc.Tuners[lineup.ID]; ok { tuner <- true diff --git a/api/xmltv.go b/api/xmltv.go index aa8f912..f725ef7 100644 --- a/api/xmltv.go +++ b/api/xmltv.go @@ -10,7 +10,7 @@ import ( "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" - "github.com/tellytv/telly/internal/guide_providers" + "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/internal/xmltv" ) @@ -39,10 +39,10 @@ func xmlTV(cc *context.CContext, c *gin.Context) { for _, channel := range lineup.Channels { epgMatchMap[channel.GuideChannel.XMLTVID] = channel.ID - var guideChannel guide_providers.Channel + var guideChannel guideproviders.Channel if jsonErr := json.Unmarshal(channel.GuideChannel.Data, &guideChannel); jsonErr != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while unmarshalling lineupchannel to guide_providers.channel: %s", jsonErr)) + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while unmarshalling lineupchannel to guideproviders.channel: %s", jsonErr)) return } diff --git a/context/context.go b/context/context.go index aed4637..f6c7860 100644 --- a/context/context.go +++ b/context/context.go @@ -6,12 +6,12 @@ import ( "os" "github.com/jmoiron/sqlx" - _ "github.com/mattn/go-sqlite3" + // _ "github.com/mattn/go-sqlite3" // the SQLite driver "github.com/pressly/goose" "github.com/sirupsen/logrus" "github.com/spf13/viper" - "github.com/tellytv/telly/internal/guide_providers" - "github.com/tellytv/telly/internal/video_providers" + "github.com/tellytv/telly/internal/guideproviders" + "github.com/tellytv/telly/internal/videoproviders" "github.com/tellytv/telly/models" ) @@ -21,8 +21,8 @@ type CContext struct { Ctx ctx.Context Log *logrus.Logger Tuners map[int]chan bool - GuideSourceProviders map[int]guide_providers.GuideProvider - VideoSourceProviders map[int]video_providers.VideoProvider + GuideSourceProviders map[int]guideproviders.GuideProvider + VideoSourceProviders map[int]videoproviders.VideoProvider RawSQL *sqlx.DB } @@ -97,7 +97,7 @@ func NewCContext() (*CContext, error) { log.WithError(guideSourcesErr).Panicln("error initializing video sources") } - guideSourceProvidersMap := make(map[int]guide_providers.GuideProvider) + guideSourceProvidersMap := make(map[int]guideproviders.GuideProvider) for _, guideSource := range guideSources { providerCfg := guideSource.ProviderConfiguration() @@ -113,7 +113,7 @@ func NewCContext() (*CContext, error) { log.WithError(videoSourcesErr).Panicln("error initializing video sources") } - videoSourceProvidersMap := make(map[int]video_providers.VideoProvider) + videoSourceProvidersMap := make(map[int]videoproviders.VideoProvider) for _, videoSource := range videoSources { providerCfg := videoSource.ProviderConfiguration() diff --git a/internal/guide_providers/main.go b/internal/guideproviders/main.go similarity index 83% rename from internal/guide_providers/main.go rename to internal/guideproviders/main.go index c325b8d..9cc15e6 100644 --- a/internal/guide_providers/main.go +++ b/internal/guideproviders/main.go @@ -1,6 +1,6 @@ -// Package guide_providers is a telly internal package to provide electronic program guide (EPG) data. +// Package guideproviders is a telly internal package to provide electronic program guide (EPG) data. // It is generally modeled after the XMLTV standard with slight deviations to accomodate other providers. -package guide_providers +package guideproviders import ( "strings" @@ -8,6 +8,7 @@ import ( "github.com/tellytv/telly/internal/xmltv" ) +// Configuration is the basic configuration struct for guideproviders with generic values for specific providers. type Configuration struct { Name string `json:"-"` Provider string @@ -21,6 +22,7 @@ type Configuration struct { XMLTVURL string } +// GetProvider returns an initialized GuideProvider for the Configuration. func (i *Configuration) GetProvider() (GuideProvider, error) { switch strings.ToLower(i.Provider) { case "schedulesdirect", "schedules-direct", "sd": @@ -44,6 +46,7 @@ type Channel struct { Lineup string } +// XMLTV returns the xmltv.Channel representation of the Channel. func (c *Channel) XMLTV() xmltv.Channel { ch := xmltv.Channel{ ID: c.ID, diff --git a/internal/guide_providers/schedules_direct.go b/internal/guideproviders/schedules_direct.go similarity index 96% rename from internal/guide_providers/schedules_direct.go rename to internal/guideproviders/schedules_direct.go index c515604..e364670 100644 --- a/internal/guide_providers/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -1,4 +1,4 @@ -package guide_providers +package guideproviders import ( "fmt" @@ -11,6 +11,7 @@ import ( "github.com/tellytv/telly/utils" ) +// SchedulesDirect is a GuideProvider supporting the Schedules Direct JSON service. type SchedulesDirect struct { BaseConfig Configuration @@ -29,14 +30,17 @@ func newSchedulesDirect(config *Configuration) (GuideProvider, error) { return provider, nil } +// Name returns the name of the GuideProvider. func (s *SchedulesDirect) Name() string { return "Schedules Direct" } +// Channels returns a slice of Channel that the provider has available. func (s *SchedulesDirect) Channels() ([]Channel, error) { return s.channels, nil } +// Schedule returns a slice of xmltv.Programme for the given channelIDs. func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, error) { // First, convert the string slice of channelIDs into a slice of schedule requests. reqs := make([]schedulesdirect.StationScheduleRequest, 0) @@ -117,8 +121,8 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro Lang: station.Station.BroadcastLanguage[0], }}, Length: &length, - Start: &xmltv.Time{airing.AirDateTime}, - Stop: &xmltv.Time{endTime}, + Start: &xmltv.Time{Time: airing.AirDateTime}, + Stop: &xmltv.Time{Time: endTime}, } // Now for the fields that have to be parsed. @@ -295,7 +299,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro if !time.Time(programInfo.OriginalAirDate).IsZero() { if !airing.New { xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ - Start: xmltv.Time{time.Time(programInfo.OriginalAirDate)}, + Start: xmltv.Time{Time: time.Time(programInfo.OriginalAirDate)}, } } timeToUse := time.Time(programInfo.OriginalAirDate) @@ -355,6 +359,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro return programmes, nil } +// Refresh causes the provider to request the latest information. func (s *SchedulesDirect) Refresh() error { if s.client == nil { sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) @@ -463,6 +468,7 @@ func (s *SchedulesDirect) Refresh() error { return nil } +// Configuration returns the base configuration backing the provider. func (s *SchedulesDirect) Configuration() Configuration { return s.BaseConfig } diff --git a/internal/guide_providers/xmltv.go b/internal/guideproviders/xmltv.go similarity index 80% rename from internal/guide_providers/xmltv.go rename to internal/guideproviders/xmltv.go index 1b0ffcb..43b5790 100644 --- a/internal/guide_providers/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -1,4 +1,4 @@ -package guide_providers +package guideproviders import ( "fmt" @@ -7,6 +7,7 @@ import ( "github.com/tellytv/telly/utils" ) +// XMLTV is a GuideProvider supporting XMLTV files. type XMLTV struct { BaseConfig Configuration @@ -24,14 +25,17 @@ func newXMLTV(config *Configuration) (GuideProvider, error) { return provider, nil } +// Name returns the name of the GuideProvider. func (x *XMLTV) Name() string { return "XMLTV" } +// Channels returns a slice of Channel that the provider has available. func (x *XMLTV) Channels() ([]Channel, error) { return x.channels, nil } +// Schedule returns a slice of xmltv.Programme for the given channelIDs. func (x *XMLTV) Schedule(channelIDs []string) ([]xmltv.Programme, error) { channelIDMap := make(map[string]struct{}) for _, chanID := range channelIDs { @@ -49,6 +53,7 @@ func (x *XMLTV) Schedule(channelIDs []string) ([]xmltv.Programme, error) { return filteredProgrammes, nil } +// Refresh causes the provider to request the latest information. func (x *XMLTV) Refresh() error { xTV, xTVErr := utils.GetXMLTV(x.BaseConfig.XMLTVURL, false) if xTVErr != nil { @@ -80,6 +85,7 @@ func (x *XMLTV) Refresh() error { return nil } +// Configuration returns the base configuration backing the provider func (x *XMLTV) Configuration() Configuration { return x.BaseConfig } diff --git a/internal/video_providers/m3u.go b/internal/videoproviders/m3u.go similarity index 82% rename from internal/video_providers/m3u.go rename to internal/videoproviders/m3u.go index 3a6cb12..089aaa1 100644 --- a/internal/video_providers/m3u.go +++ b/internal/videoproviders/m3u.go @@ -1,4 +1,4 @@ -package video_providers +package videoproviders import ( "fmt" @@ -8,6 +8,7 @@ import ( "github.com/tellytv/telly/utils" ) +// M3U is a VideoProvider supporting M3U files. type M3U struct { BaseConfig Configuration @@ -28,18 +29,22 @@ func newM3U(config *Configuration) (VideoProvider, error) { return m3u, nil } +// Name returns the name of the VideoProvider. func (m *M3U) Name() string { return "M3U" } +// Categories returns a slice of Category that the provider has available. func (m *M3U) Categories() ([]Category, error) { return m.categories, nil } +// Formats returns a slice of strings containing the valid video formats. func (m *M3U) Formats() ([]string, error) { return m.seenFormats, nil } +// Channels returns a slice of Channel that the provider has available. func (m *M3U) Channels() ([]Channel, error) { outputChannels := make([]Channel, 0) for _, channel := range m.channels { @@ -48,13 +53,15 @@ func (m *M3U) Channels() ([]Channel, error) { return outputChannels, nil } +// StreamURL returns a fully formed URL to a video stream for the given streamID and wantedFormat. func (m *M3U) StreamURL(streamID int, wantedFormat string) (string, error) { if val, ok := m.channels[streamID]; ok { - return val.streamUrl, nil + return val.streamURL, nil } return "", fmt.Errorf("that channel id (%d) does not exist in the video source lineup", streamID) } +// Refresh causes the provider to request the latest information. func (m *M3U) Refresh() error { playlist, m3uErr := utils.GetM3U(m.BaseConfig.M3UURL, false) if m3uErr != nil { @@ -123,13 +130,14 @@ func (m *M3U) Refresh() error { Category: categoryVal, EPGID: epgIDVal, - streamUrl: track.URI, + streamURL: track.URI, } } return nil } +// Configuration returns the base configuration backing the provider func (m *M3U) Configuration() Configuration { return m.BaseConfig } diff --git a/internal/video_providers/main.go b/internal/videoproviders/main.go similarity index 85% rename from internal/video_providers/main.go rename to internal/videoproviders/main.go index c319fd3..afd5839 100644 --- a/internal/video_providers/main.go +++ b/internal/videoproviders/main.go @@ -1,9 +1,9 @@ -package video_providers +// Package videoproviders is a telly internal package to provide video stream information. +package videoproviders import ( "regexp" "strings" - "time" ) var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch @@ -11,6 +11,7 @@ var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString var hdRegex = regexp.MustCompile(`hd|4k`) +// Configuration is the basic configuration struct for videoproviders with generic values for specific providers. type Configuration struct { Name string `json:"-"` Provider string @@ -28,6 +29,7 @@ type Configuration struct { EPGIDKey string } +// GetProvider returns an initialized VideoProvider for the Configuration. func (i *Configuration) GetProvider() (VideoProvider, error) { switch strings.ToLower(i.Provider) { case "xtream", "xstream": @@ -37,13 +39,6 @@ func (i *Configuration) GetProvider() (VideoProvider, error) { } } -type AccountInfo struct { - MaximumConnections int - ActiveConnections int - ExpirationDate time.Time - Status string -} - // Category describes a grouping of streams. type Category struct { Name string `json:"name"` @@ -72,7 +67,7 @@ type Channel struct { EPGID string // Only needed for M3U provider - streamUrl string + streamURL string } // VideoProvider describes a IPTV provider configuration. diff --git a/internal/video_providers/xtream.go b/internal/videoproviders/xtream.go similarity index 76% rename from internal/video_providers/xtream.go rename to internal/videoproviders/xtream.go index 19e81c7..781379e 100644 --- a/internal/video_providers/xtream.go +++ b/internal/videoproviders/xtream.go @@ -1,4 +1,4 @@ -package video_providers +package videoproviders import ( "fmt" @@ -6,6 +6,7 @@ import ( xc "github.com/tellytv/go.xtream-codes" ) +// XtreamCodes is a VideoProvider supporting Xtream-Codes IPTV servers. type XtreamCodes struct { BaseConfig Configuration @@ -24,10 +25,12 @@ func newXtreamCodes(config *Configuration) (VideoProvider, error) { return xc, nil } +// Name returns the name of the VideoProvider. func (x *XtreamCodes) Name() string { return "Xtream Codes Server" } +// Categories returns a slice of Category that the provider has available. func (x *XtreamCodes) Categories() ([]Category, error) { outputCats := make([]Category, 0) for _, cat := range x.categories { @@ -39,18 +42,24 @@ func (x *XtreamCodes) Categories() ([]Category, error) { return outputCats, nil } +// Formats returns a slice of strings containing the valid video formats. func (x *XtreamCodes) Formats() ([]string, error) { return x.client.UserInfo.AllowedOutputFormats, nil } +// Channels returns a slice of Channel that the provider has available. func (x *XtreamCodes) Channels() ([]Channel, error) { return x.channels, nil } +// StreamURL returns a fully formed URL to a video stream for the given streamID and wantedFormat. +// Refresh causes the provider to request the latest information. +// Configuration returns the base configuration backing the provider func (x *XtreamCodes) StreamURL(streamID int, wantedFormat string) (string, error) { return x.client.GetStreamURL(streamID, wantedFormat) } +// Refresh causes the provider to request the latest information. func (x *XtreamCodes) Refresh() error { client, clientErr := xc.NewClient(x.BaseConfig.Username, x.BaseConfig.Password, x.BaseConfig.BaseURL) if clientErr != nil { @@ -102,6 +111,7 @@ func (x *XtreamCodes) Refresh() error { return nil } +// Configuration returns the base configuration backing the provider func (x *XtreamCodes) Configuration() Configuration { return x.BaseConfig } diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index d9fc59b..49c0e2d 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -39,8 +39,10 @@ func (t *Time) UnmarshalXMLAttr(attr xml.Attr) error { return nil } +// Date is the XMLTV specific formatting of a date (YYYYMMDD/20060102) type Date time.Time +// MarshalXML is used to marshal a Go time.Time into the XMLTV Date Format. func (p Date) MarshalXML(e *xml.Encoder, start xml.StartElement) error { t := time.Time(p) if t.IsZero() { @@ -49,6 +51,7 @@ func (p Date) MarshalXML(e *xml.Encoder, start xml.StartElement) error { return e.EncodeElement(t.Format("20060102"), start) } +// UnmarshalXML is used to unmarshal a time in the XMLTV Date format to a time.Time. func (p *Date) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) { var content string if e := d.DecodeElement(&content, &start); e != nil { @@ -61,14 +64,15 @@ func (p *Date) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) dateFormat = "2006" } - if v, e := time.Parse(dateFormat, content); e != nil { + v, e := time.Parse(dateFormat, content) + if e != nil { return fmt.Errorf("the type Date field of %s is not a time, value is: %s", start.Name.Local, content) - } else { - *p = Date(v) } + *p = Date(v) return nil } +// MarshalJSON is used to marshal a Go time.Time into the XMLTV Date Format. func (p Date) MarshalJSON() ([]byte, error) { t := time.Time(p) str := "\"" + t.Format("20060102") + "\"" @@ -76,14 +80,15 @@ func (p Date) MarshalJSON() ([]byte, error) { return []byte(str), nil } +// UnmarshalJSON is used to unmarshal a time in the XMLTV Date format to a time.Time. func (p *Date) UnmarshalJSON(text []byte) (err error) { strDate := string(text[1 : 8+1]) - if v, e := time.Parse("20060102", strDate); e != nil { + v, e := time.Parse("20060102", strDate) + if e != nil { return fmt.Errorf("Date should be a time, error value is: %s", strDate) - } else { - *p = Date(v) } + *p = Date(v) return nil } diff --git a/metrics/metrics.go b/metrics/metrics.go index a1c529c..680f320 100644 --- a/metrics/metrics.go +++ b/metrics/metrics.go @@ -17,6 +17,7 @@ var ( }, []string{"lineup_name"}, ) + // ActiveStreams tracks the realtime number of active streams. ActiveStreams = prometheus.NewGaugeVec( prometheus.GaugeOpts{ Namespace: "telly", @@ -26,6 +27,7 @@ var ( }, []string{"lineup_name"}, ) + // StreamTime reports the total amount of time streamed since startup. StreamTime = prometheus.NewGaugeVec( prometheus.GaugeOpts{ Namespace: "telly", diff --git a/models/guide_source.go b/models/guide_source.go index acb4693..28e6fc9 100644 --- a/models/guide_source.go +++ b/models/guide_source.go @@ -5,7 +5,7 @@ import ( "time" "github.com/jmoiron/sqlx" - "github.com/tellytv/telly/internal/guide_providers" + "github.com/tellytv/telly/internal/guideproviders" ) // GuideSourceDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -29,6 +29,7 @@ func (db *GuideSourceDB) tableName() string { return "guide_source" } +// GuideSource describes a source of EPG data. type GuideSource struct { ID int `db:"id"` Name string `db:"name"` @@ -41,8 +42,9 @@ type GuideSource struct { Channels []GuideSourceChannel `db:"-"` } -func (g *GuideSource) ProviderConfiguration() *guide_providers.Configuration { - return &guide_providers.Configuration{ +// ProviderConfiguration returns a guideproviders.Configurator for the GuideSource. +func (g *GuideSource) ProviderConfiguration() *guideproviders.Configuration { + return &guideproviders.Configuration{ Name: g.Name, Provider: g.Provider, Username: g.Username, diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index ee45ac4..5ee9379 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -6,7 +6,7 @@ import ( "time" "github.com/jmoiron/sqlx" - "github.com/tellytv/telly/internal/guide_providers" + "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/internal/xmltv" ) @@ -31,6 +31,7 @@ func (db *GuideSourceChannelDB) tableName() string { return "guide_source_channel" } +// GuideSourceChannel is a single channel in a guide providers lineup. type GuideSourceChannel struct { ID int `db:"id"` GuideID int `db:"guide_id"` @@ -45,7 +46,7 @@ type GuideSourceChannel struct { // GuideSourceChannelAPI contains all methods for the User struct type GuideSourceChannelAPI interface { - InsertGuideSourceChannel(guideID int, channel guide_providers.Channel) (*GuideSourceChannel, error) + InsertGuideSourceChannel(guideID int, channel guideproviders.Channel) (*GuideSourceChannel, error) DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) @@ -62,7 +63,7 @@ SELECT FROM guide_source_channel G` // InsertGuideSourceChannel inserts a new GuideSourceChannel into the database. -func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel guide_providers.Channel) (*GuideSourceChannel, error) { +func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel guideproviders.Channel) (*GuideSourceChannel, error) { marshalled, marshalErr := json.Marshal(channel) if marshalErr != nil { return nil, marshalErr diff --git a/models/guide_source_programme.go b/models/guide_source_programme.go index f0430ab..195ddc2 100644 --- a/models/guide_source_programme.go +++ b/models/guide_source_programme.go @@ -31,6 +31,7 @@ func (db *GuideSourceProgrammeDB) tableName() string { return "guide_source_programme" } +// GuideSourceProgramme is a single programme available in a guide providers lineup. type GuideSourceProgramme struct { GuideID int `db:"guide_id"` Channel string `db:"channel"` diff --git a/models/lineup.go b/models/lineup.go index dcd4ef2..ce3ed02 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -68,6 +68,7 @@ func (d *DiscoveryData) UPNP() upnp.RootDevice { } } +// Lineup describes a collection of channels exposed to the world with associated configuration. type Lineup struct { ID int `db:"id"` Name string `db:"name"` @@ -89,6 +90,7 @@ type Lineup struct { Channels []LineupChannel } +// GetDiscoveryData returns DiscoveryData for the Lineup. func (s *Lineup) GetDiscoveryData() DiscoveryData { baseAddr := fmt.Sprintf("http://%s:%d", s.DiscoveryAddress, s.Port) return DiscoveryData{ diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 0c261f0..1197a02 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -42,6 +42,7 @@ type HDHomeRunLineupItem struct { VideoCodec string `xml:",omitempty" json:",omitempty"` } +// LineupChannel is a single channel available in a Lineup. type LineupChannel struct { ID int `db:"id"` LineupID int `db:"lineup_id"` @@ -64,6 +65,7 @@ func (l *LineupChannel) String() string { return fmt.Sprintf("channel: %s (ch#: %s, video source name: %s, video source provider type: %s)", l.Title, l.ChannelNumber, l.VideoTrack.VideoSource.Name, l.VideoTrack.VideoSource.Provider) } +// Fill will insert Lineup, GuideChannel and VideoTrack into the LineupChannel. func (l *LineupChannel) Fill(api *APICollection) { if l.lineup == nil { // Need to get the address and port number to properly fill @@ -91,6 +93,7 @@ func (l *LineupChannel) Fill(api *APICollection) { l.HDHR = l.HDHomeRunLineupItem() } +// HDHomeRunLineupItem returns a HDHomeRunLineupItem for the LineupChannel. func (l *LineupChannel) HDHomeRunLineupItem() *HDHomeRunLineupItem { return &HDHomeRunLineupItem{ DRM: ConvertibleBoolean(false), diff --git a/models/types.go b/models/types.go index 7e8791a..9b96157 100644 --- a/models/types.go +++ b/models/types.go @@ -6,8 +6,10 @@ import ( "fmt" ) +// ConvertibleBoolean is a helper type to allow JSON documents using 0/1 or "true" and "false" be converted to bool. type ConvertibleBoolean bool +// MarshalJSON returns a 0 or 1 depending on bool state. func (bit *ConvertibleBoolean) MarshalJSON() ([]byte, error) { var bitSetVar int8 if *bit { @@ -17,6 +19,7 @@ func (bit *ConvertibleBoolean) MarshalJSON() ([]byte, error) { return json.Marshal(bitSetVar) } +// UnmarshalJSON converts a 0, 1, true or false into a bool func (bit *ConvertibleBoolean) UnmarshalJSON(data []byte) error { asString := string(data) if asString == "1" || asString == "true" { diff --git a/models/video_source.go b/models/video_source.go index 7f9133c..df3b6ff 100644 --- a/models/video_source.go +++ b/models/video_source.go @@ -5,7 +5,7 @@ import ( "time" "github.com/jmoiron/sqlx" - "github.com/tellytv/telly/internal/video_providers" + "github.com/tellytv/telly/internal/videoproviders" ) // VideoSourceDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -29,6 +29,7 @@ func (db *VideoSourceDB) tableName() string { return "video_source" } +// VideoSource is a source of video streams. type VideoSource struct { ID int `db:"id"` Name string `db:"name"` @@ -43,8 +44,9 @@ type VideoSource struct { Tracks []VideoSourceTrack `db:"tracks"` } -func (v *VideoSource) ProviderConfiguration() *video_providers.Configuration { - return &video_providers.Configuration{ +// ProviderConfiguration returns an initialized videoproviders.Configuration for the VideoSource. +func (v *VideoSource) ProviderConfiguration() *videoproviders.Configuration { + return &videoproviders.Configuration{ Name: v.Name, Provider: v.Provider, Username: v.Username, diff --git a/models/video_source_track.go b/models/video_source_track.go index 16534ef..d3829cc 100644 --- a/models/video_source_track.go +++ b/models/video_source_track.go @@ -28,6 +28,7 @@ func (db *VideoSourceTrackDB) tableName() string { return "video_source_track" } +// VideoSourceTrack is a single stream available from a video source. type VideoSourceTrack struct { ID int `db:"id"` VideoSourceID int `db:"video_source_id"` diff --git a/utils/main.go b/utils/main.go index fb542a9..945a83f 100644 --- a/utils/main.go +++ b/utils/main.go @@ -17,9 +17,11 @@ import ( ) var ( - safeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) + // SafeStringsRegex will match any usernames, passwords or tokens in a string. + SafeStringsRegex = regexp.MustCompile(`(?m)(username|password|token)=[\w=]+(&?)`) - stringSafer = func(input string) string { + // StringSafer will replace sensitive values (username, password and token) with safed values. + StringSafer = func(input string) string { ret := input if strings.HasPrefix(input, "username=") { ret = "username=REDACTED" @@ -35,6 +37,7 @@ var ( } ) +// GetTCPAddr attempts to convert a string found via viper to a net.TCPAddr. Will panic on error. func GetTCPAddr(key string) *net.TCPAddr { addr, addrErr := net.ResolveTCPAddr("tcp", viper.GetString(key)) if addrErr != nil { @@ -43,8 +46,9 @@ func GetTCPAddr(key string) *net.TCPAddr { return addr } +// GetM3U is a helper function to download/open and parse a M3U Plus file. func GetM3U(path string, cacheFiles bool) (*m3uplus.Playlist, error) { - // safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + // safePath := SafeStringsRegex.ReplaceAllStringFunc(path, StringSafer) file, _, err := GetFile(path, cacheFiles) if err != nil { @@ -63,8 +67,9 @@ func GetM3U(path string, cacheFiles bool) (*m3uplus.Playlist, error) { return rawPlaylist, nil } +// GetXMLTV is a helper function to download/open and parse a XMLTV file. func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { - // safePath := safeStringsRegex.ReplaceAllStringFunc(path, stringSafer) + // safePath := SafeStringsRegex.ReplaceAllStringFunc(path, StringSafer) file, _, err := GetFile(path, cacheFiles) if err != nil { @@ -78,12 +83,13 @@ func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { } if closeXMLErr := file.Close(); closeXMLErr != nil { - return nil, fmt.Errorf("error when closing xml reader", closeXMLErr) + return nil, fmt.Errorf("error when closing xml reader: %s", closeXMLErr) } return tvSetup, nil } +// GetFile is a helper function to download/open and parse a file. func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { transport := "disk" @@ -133,6 +139,7 @@ func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { return file, transport, nil } +// ChunkStringSlice will return a slice of slice of strings for the given chunkSize. func ChunkStringSlice(sl []string, chunkSize int) [][]string { var divided [][]string @@ -155,6 +162,7 @@ func writeFile(path, transport string, reader io.ReadCloser) (io.ReadCloser, str return reader, transport, nil } +// Contains returns true if the given element "e" is found inside the slice of strings "s". func Contains(s []string, e string) bool { for _, ss := range s { if e == ss { @@ -164,6 +172,7 @@ func Contains(s []string, e string) bool { return false } +// GetStringMapKeys returns a slice of strings for the keys of a map. func GetStringMapKeys(s map[string]struct{}) []string { keys := make([]string, 0) for key := range s { @@ -259,6 +268,7 @@ func lowerDelimiterCase(s string, delimiter rune) string { return string(buffer) } +// PadNumberWithZeros will pad the given value integer with 0's until expectedLength is met. func PadNumberWithZeros(value int, expectedLength int) string { padded := fmt.Sprintf("%02d", value) valLength := CountDigits(value) @@ -268,6 +278,7 @@ func PadNumberWithZeros(value int, expectedLength int) string { return padded } +// CountDigits will count the number of digits in an integer. func CountDigits(i int) int { count := 0 if i == 0 { From f12f1b6f2c716275dabd7cee0d464730a0dc3b2a Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 02:22:09 -0700 Subject: [PATCH 075/182] Ignore gometalinter files --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 83fb9f9..a2f0f40 100644 --- a/.gitignore +++ b/.gitignore @@ -12,3 +12,4 @@ vendor/ *.tar.gz telly.config.* *.db +.gometalinter-* From 3556e7dc589d2fc95f7103c56324d3c771b96602 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 02:22:20 -0700 Subject: [PATCH 076/182] Uncomment sqlite3 import --- context/context.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/context/context.go b/context/context.go index f6c7860..10d903c 100644 --- a/context/context.go +++ b/context/context.go @@ -6,7 +6,7 @@ import ( "os" "github.com/jmoiron/sqlx" - // _ "github.com/mattn/go-sqlite3" // the SQLite driver + _ "github.com/mattn/go-sqlite3" // the SQLite driver "github.com/pressly/goose" "github.com/sirupsen/logrus" "github.com/spf13/viper" From 1e18b1849a832357eabc6c236ee0983074e04c15 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 18:08:21 -0400 Subject: [PATCH 077/182] initial channels if nil --- internal/videoproviders/m3u.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/internal/videoproviders/m3u.go b/internal/videoproviders/m3u.go index 089aaa1..8850e00 100644 --- a/internal/videoproviders/m3u.go +++ b/internal/videoproviders/m3u.go @@ -122,6 +122,10 @@ func (m *M3U) Refresh() error { } } + if m.channels == nil { + m.channels = make(map[int]Channel) + } + m.channels[channelID] = Channel{ Name: nameVal, StreamID: channelID, From bad23a27e10ad34c9b4d3c60da30fc574eccabf3 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 15:11:10 -0700 Subject: [PATCH 078/182] Update frontend --- api/a_api-packr.go | 9 +++++---- frontend | 2 +- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index 565582f..d9f0b8b 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -8,11 +8,12 @@ import "github.com/gobuffalo/packr" // and any other packr generated files. func init() { packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/yyQT4/jIAzFv4rluxMwkGFWpYedSy97nTui+YOUJhVkSDWffkUayYKnn20eepdcRvApepri/d4vDrf00yPc/ebpmfohvhwOPp8khrWOFIQw+5wd5jJSXOa49ESDh8HTVuq5EwuEtM69w/gYEV6PeckOp217/mnbfd+bXTVrGlsWQrS5jAgl9vvf9eVQgIBOCzCS8Xp5+m2CIc6zw/CTUr9sX+u8JoS7w3/mk0HctP1i2Rioi6fQtigWQQB3jXlDbd81sTaNLIonkp0IJD+aDxCkGKRuVL0V5yrhkKB4UlaH9xgoprNHijOdK+86Hiyk+GY+ORzO9Sd02pO239oGQbVzQDogafv7INmBMnzr9HenJyO5sLW/eL20NYDrpWZ0/R8AAP//F4XLEq8BAAA=\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/6RTXW/TMBR9768wfh2NRze2DMVBsK9uE3RDA6q9ec5N4+CP1PcmXfrrURs+tAlNIJ6Sc67P8T1X19mLImjqG2AVOZuPss2HWeUXkoPnGwJUkY8YyxyQYrpSEYEkb6kcp3xbIEMW8luwts/EADb0vUJgVYRScsF/O3jlQPLOwKoJkTjTwRN4knxlCqpkAZ3RMN6Cl8x4Q0bZMWplQb4abKzx31gEK7nRwXO2aV9y49QCxMN44IZ7S9VtYGJ0eNvJCc9Hj/VIvQWsAOinoiJq8I0QLUJSBk9qBRgcJDo4EcGCQkDRvU4mya7QiAKDNUWiETkznmARDfWSY6X20v3xyr87PrR+Z/5x9/NVoa+7y46WF9O9elbjUeOv/PJoOT9IL9y8m52vJ5ftWTg1x/VtWvd3N/PJmjMdA2KIZmG85MoH37vQ4tMx/H+MR2f+HGZ6777eTlV/1OCHdNmvT6+udRqK6f4Jztp1ATX5uDM7oxM30xdffLX4BDf753fvp4ftStflwTNhno0yMNuu8kwM25jdh6LfDkE1zTiGQHkmfv2OMtTRNPRjMQgeSNSqUwPLGUYteWw9GQdJvbUdSvnfCJtg+9JYi/8udcr4JyoxJMnE8Py+BwAA//+4MjUqjwMAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/6xTXU/bShB9z6/w3dfc2NzAhVB5jVq+AoiGj7SNeNusx/aa/XB2xg6O+PGV44q2qEKt1Cd7zsyZc441jv9JnaS2gqAgo5NB3D0CLWzOGVjWASDSZBAEsQESgSyERyDOaspGE7ZtkCINyRy0buOoLzp4KRCCwkPGWcS+b7DCAGeNgnXlPLFAOktgibO1SqngKTRKwmhb/Bsoq0gJPUIpNPD/+jVa2cfAg+ZMSWdZ0NnnTBmRQ/Q06rFeNxNNV4ZKuqOGj1kyeOH3AwVRhe+iKHOWMMydyzWISmEonYkk4lEmjNItv3NLR+75XuVWPYrn+0J4GM5BFsNrZx3r3SC1GrAAoNc+f+i8Eq4Rwk5crAGdga2uBw0CAaPm/3Ac7nQ+InRapaFEZIGyBLlX1HKGhdid7I3W9v3xgbbDxcedT1epvGkuG1pdTHfLWYmHlb2yq8PVYn9yYRbN7HwzvqzP3Kk6LueTsn24XYw3LJDeITqvcmU5E9bZ1rga/36Mn2Z+HWa6NF/mU9EeVng9WbWb06sbOXHpdO8EZ/UmhZKsH87O6MTM5MVnW+R3cLt3/vBhelCvZZntvxHmzSg9snWVxFF/9fHSpe32I4iqGnnnKImjl9dBjNKrir4dIMETRaVoRI+yAL3kzNeWlIGw3K7tW8nvECun20xpjX9ONULZV6yoTxJH/W/+NQAA//9rvAnH9wMAAA==\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"H4sIAAAAAAAA/+y9e6/jOJIn+v/9FJ5TSFSeLsslyZZfB1nonro92Aa6+gLTs8ACtbmAbNG2OvVaSc6jU4bns1/wJfERlCj5ZE/txe3sypTJYDAYDAbJH18//uFf/q/ZH2b/mud1VZdhMfu6WniL5ezjpa6Lav/jj2dUH3jk4pinPz5j+p/z4q2Mz5d65rue5/iut539xwUJfP50rS95WRmJX+O6RuV89pfsuMBEf42PKKtQNLtmESpnv/zlPwQZ4vpyPZDc69dD9WMr0I+HJD/8mIZVjcof//qXn//8t7//Gcv34yI7OxVK0LHuvpy8QBmKfhJCjnlWh3GGytshPH45l/k1i/bfnU6nl0NeRqh0jnmSl/vvDkv8Z/bd8XicfRft8J/72Cz2l/wrzihvnOoSRvnrPsszNJrNDAeGZZm/3uq82Dt+0cjC1mWYVUVYoqyeid/f7XY7TvkaR/Vl786CosH/PSBEWyobCdbrdV9WQsAhr+s8NVQVzYuSOMSwnDKM4mu1d1/kyASdujjLrOu86M23zgtDpjjGIsdTfrxWKNpnef1RE+S5N29mjq67QcRGW1OKswrVM3fmFQ35rzwfwo/uHP9ZuJvgee7O8J9lF+X567kfBPOF9wyLGcVVeEiG2wsX6rTDfwRexEguYeV8DZMrIr+KJDyiS55EqLxFcVUk4ZvaCma22XWNlKl71baEPVZBlSdxRJrsSxpnzgXhOtsv10XzEibxOXPiGqXV/oiyGpVDAuiNl+ralTW9fh5iRAKJQoTS6fK8FGEUxdmZ2NPec6U2as1Y0znTXRiGcJ1XcXZOEFwFggJHJzYKF2fFtb6RQrp6mdsQ0t72AQ7CTs/ostJrUsdFgmzN2CgXCTMaOWBmaIn//DOkEmKT8ICSG1MSdef9EtibpFQXG6EqrPQ/zgiosk95hm3oN7Rf7FD6koblOc54zRcND6CenYQA1ROcQs0v+LBf8JF7Or17MbpIXsXvbUXvIpTJiGh9f4v6FWLjY57NvyF/WiLev8RZEmfIOST58cvLt2grxjLyTkOr/2iLwlP0rbNf4LrkIwfajr69/asykHy5ENSxf0sZaH/CjZn5iqXgvogIy/ete7GHZe7xRREh6BeBsDkmKCyd1zIsiq6r3u20IZVE14Uwa+Mm5rq+d9AGDUWcZah0fsszdFM6114f3w34WwH15HRW4Q+lpIIK8xhh+MyklycKOgs9caeumWH6wXuFqn5L0J5YoDwdYpOhmb/gJYjKvIjy18wpwgwlvYNQdchpOVKUc9AmQMScPNf98NIz6enGvdC0R4gVFIzW+A/vU8lE0gMLrYk002noyJVE5EUd59k+CavaOV7iJOqbrQ0K3i9PnRc31rxEFWnzM0UDBuUwCUD9sFyGVVTnhZV+TnGpKmik2IAccs4XFEbqZFk1Ut4bYqvfWPA85XktTYQfZSio5ybrGlb1oHJx8yxuzis6fIlr51rh9k6qhkwzX5w0/w0KrfRALYCXbYun2HgmQgasr4hNTdwXajpiKw9Wzy/Ha1nl5b7I43aeOaVMnfF0A0vGOkKn8JrU78E6Dcsv4IgVHU4B66kfzIKqFB4W09G7qNe1607JNM4zg7fWK2m7edbqdmKeUDFZ3svl0jhfeb/chFg2Cn4fZdqbyEtX3sfz6iydMj0ej48zpV5XGoz5/uQqJ591eFamUd2gqJvWbt0Pkm2vXPe+L/O8vjnOIbkigusdTqcXx4mzKD7neBzkuSf/xXGKa1kkaP/d+rTyjx4OiLMv++/Qdom2xxfHKVG0/y46LoNV8OI4eRlmZ7T/7hRtkLd6cZw3lCT5K24BR8/dvDjOuUQo23/nb8MNSVGjMNl/57vH3Q5HH9/CbP+dtwn9w/bFcV4vcY1o+8FJw7f9d+vjJthE7KcTheWX/XfL1TJcuVi4Mk7D8k0oUIWOeRaRsDZldT0eUVUJUsTZKRezDcsMt8pO7AiXqxRKmhBNfnfannankBBIghxKFH4hrtdpqr0SUqX7YLMuGjk0jfab9VYNTc773c5XQ5tk7/muS4JJzZ7CNE7enCrMKqdCZXzaO2FRJMip3qoapfN/TeLsyy/h8e/k57/lWT1/+js652j23//yNP/3/JDX+fzpv6HkK6rjYzj7G7qip/mfyjhM5h3T+dOfMNPZz7hVzP6c5v+Inzo+esDf39JDnjzNn/6W17mUSpE7zbO8KsIj2v/9337Js9z5d3S+JmE5/wVlST7/Jc/CYz7/Oc+qPAmr+dNf4wMqQ9IMMPnT/Onn/FrGqJz9Db0+zVt29z/M9/vwVKNyvt8f0CkvEYVS499w/bZjlOZ+qVPms6hI+67UL2Qaz1BIb+EFL7ybr1FDm5gTRv+4VjUdDuJe3RyDpyCnJH/l04FjmSfJISw7pmHhXOLzhViYvrBx/yPm8jVGr0Ve1jc6g4jQ1/iI6HTiHpZ1fEzQPKziCM1P8fkYEo+BP68lmtPB1JyO0+YX0k/O0zDO5ln4dV6hI+nFOIpB4Iv7IY/e2EBp776Ievqd21nnBb0SpaobVKo24J2I7/mBv3shtUgw8j1211A/ejrdf63DQ5xFqPn05HhPn/dkmeWWX2vMfO/+S5zimgqz+n7x5hd/flnOL6v5JZhf1jdhHuTeo2SeJ/Nifk2kcGUygMtxDw+H8tcorEMnL+NznIWJU8d1gj7PSQz9vhH5I3TMaVvZkxVOLJVswRDFLMrrGkUvgwRsLHhBSSHPaPbuPYyiElXaCLutCNoEsrxMw0Sqiji7oDKu73kyy7FSZtdkfiXfV/ytMHTvUS2NNzaue48ihWoRlB26S4H/OzHu/33Na8QaR2vjM3dGFB2dspsga1yHSXy8H+ZVXebZWcr1QICYe3U9zKtrcSvyKiYqK1ES1vFXJNjiJvggldd9+Ypwqw0TZm6HsEKYAHPjc01n4QcovWPeZN68wL/CW7c0h3s8tb7IDEKzWxGdMJiCU32Ji31++Ac61tU9lEEe1w3Wh6XZOO4hWWT89VKi0+dn+s1byefneW8sbT8DNKI0zFjAovcLojbV+zGP0PzLIZoXJZpXYVpIXcL79k2ia0LpvWiNz9jqX3jfsQ+vdd7bm9zj9HxTbCqNoyhBMhpFdFR9Pd9a1pc4ilCm2iNNe6/xqFhAvpKwqNCef9xZR3MT4bzFhrQ7BZZkoRx1oyMz1d0ydg7ux/Y04b2+3AQy7id6gHfACdwP17rGEzVptcZlwYpRUDc384rmhQfxFkMInRIXixRkhquF4PuU05yAwnM+F53TydIcyx+WKIT7U27NnXXwEMhBihl1dfg1ruJDgngszZfqjbT8U16mtOp/rd8K9KlEFao/z+mP6npI4/rznCXGA6MZjaEhn1uUIywKFJZhdkR7GnWX6PZ7gnpQLRH4dy5mZ4xmAgDxrIK0iG4lErBuohvK+XhBxy+HvPk8FwJx9eef4WFht2wjsonCGkkscEAdp8hJ8mOYSFFpntUXKQQTgjpM4qrGQ9HWPuTmXiJiDbxh3k8xSqIK1bc0zvi+mk7el9a4GEzs3hN0RlkkD+wYdE5Gp2nYOMJPlZXcjwrOiwYA1vki+2cymXPoMJ/2+feizM9khGDq/qjKsmt6QCW2CKY1uphQFVgqaqYGwvxay4R8NwFWKeNeobA8Xj7zFu/kp1OFarrBCagmod2wlF12NMA5YsJEFs1E23VYkE2QzLo0pzhBzrVI8jDi5cEV0arY3DLza41dBOQi79U1xbPmNhIbIsEbVAyxRmmRhDWSt9D8SruMz1KoMOpdXLz54uLPF5flfHFZzReXYL64rOfG0bBuaJBvFABQeRTvy3ZH8r94wjK/T3sBLNPFF8Np6HJ+Wd5E+94w8tX8srqphn/HxbkEUrjPIta4UPIM5L5IUBjp1FKZlq57XzBtOqLka4BSLX2XUixbsIByMacVNbAamVZU0tIu7aUUHfAxz2qU1cQDtyNktXcT15A8YWgvDpi473sBVw5EMNZ7vi+qNEySOfn71o+eLdKw/DLHf7Vdz8LH+ekTxONpi5b3BW1TpNXN6Y9rRjopBRHEqqlqsf8Sk5JWCTdijYwMdoUFseebtLOFGW+cxXUcJnGVCkXeuR9elNHCtShQeQwrdF90kybzxE5qB10CvpAj90GyrqUxIZC4BXKYleyf/qfveqvZ/3TdP7lP90Wcnp1Tco3x/E/q0ETPT6jqyzU9ZGGcCJVIrNV2vTVCyEdrZdcP49GXOZtrwvVIIx08gIf8odRyWmo+8pbrUFYlntyIdr1ZBC0Jw3Nf8zKiOOOe/O3ggHv4E0kqe9Uvh0hQW4nS2WIl17+UAVGgplaGs6gKxFbz5RDNxDxc0bJcpU3iCX8haFSzK1EUmimmnykqMYxbOqWwYcuiKJFD51pkQoTrmu9SXLl4psCnZW9sSnZfdDvc9DEW3ySjbdbwhP1nZWtAEohBLOqPKYricPaxGwoSgPn5JmTbGWSAZbwDiQj+bEi08Q2JCDxtSLRbGxJR9NqQyvOogF0ka9DfQHOLMn9tzeaUoOYF/0W2e+zxXzIPR2RLmJCQ+yLLnfO1rlFZyV7WVQAngfCnxTFP5mLAr8ckrKo/fDrmifNZWdFRNqm6d5oak3rsH5f9y3/79F/2z5L+s6L/BPSfNf1nQ//Z0n929B+sHvqVnPm/PC/85XafQqjffnZfy/Zr1X4F7de6/dq0X9v2a9d+dfKkEf+Xy4O/3O5TCPXbz+5r2X6t2q+g/Vq3X5v2a9t+7dqvTp4q5f9yefCX230KoX772X0t269V+xW0X+v2a9N+bduvXfvVydMk/F8uT9OZR9NZSNMZSdPaSdOaStNaS9MaTNPaTNOaTdNaTtMaT0PtBwBBxQlntzve0/Zcw02amP2NNNFDWMUV7hbwj3OZv+49pdO9t3ZMUhBQl3gBSsIcAk9BB1uk5XTk28WS/U+cHwuhNIXfpfDWizX930aaUgvBNM2yS+MHIqkfMIpVR7FcgoKIwTRN0KVZeaAkYjBNs+7SBBIOEHAdbgQKWCWBppNtl2YN62St6WTXpdlIOtlwnXiuUDmwUraaUjyhRnewVnaaVjyxUnV85L6ggxayo+pGh4aOx0PxsJsFekse6N44FMMCPE7CA3wW4POAJQtoeaxYwIoHBCwg4AFrFrDmARsWsOEBWxaw5QE7FrBrBeOiep2srbCttB4X18PyEtTE8W5ihycZBaPwJQq5XTCSpURC2gOLWUkxsvkzkkAika2dkawlEmLlLGYjx0DybyWSNST/TiLZCPJ7rqwfqACerEPJMvsGergXGOcaWa8xzjviXmy0g8T93QQfiTvHQTeJ+80JnhJ3shOcJe6RB/0l7qwnuEzcs0/wmngYMOg4yZBkgu8k45cJ7pMMdqw8aJUanGiVwn60SnVXSqxS8abE6BSHSixK8anEgBS3SqxD8ayk6hXnSmpa8a+kGhUXS+pI8bK0SlRHSxWu+lqqTs3dElUoU4wuatgZExUN+mOiNJNLJtob9MpEn4OOmWjY5JuJqgfdM1H+oIcm1WFy0rReBv00rSijq+6dX+MZxDhfzWYc43w1ngGN9tV4rjTBV+OJ1aCvxnOuCb4aT9Am+Go8mxv01XiiN8FX41nhBF+Np5CDvppMZyf4ajL3neCryUTZylenkcFXpxHsq9NI99XEKhVfTYxO8dXEohRfTQxI8dXEOhRfTape8dWkphVfTapR8dWkjhRfTatE9dVU4aqvpurUfDVRBeyriUaGfDVR0aCvJkoz+WqivUFfTfQ56KuJhk2+mqh60FcT5Q/6alIdJl9N62XQV9OKGuOrO1gzcZLzOF/N0Kpxvjo5T/DVyXmSr07OFr46OU/y1cl5kq9Ozha+OjlP8tXJeZKvTs4WvppAoRN8NcFNJ/hqArJa+erkbAInzrCvTs66ryZWqfhqYnSKryYWpfhqYkCKrybWofhqUvWKryY1rfhqUo2KryZ1pPhqWiWqr6YKV301Vafmq4kqYF9NNDLkq4mKBn01UZrJVxPtDfpqos9BX000bPLVRNWDvpoof9BXk+ow+WpaL4O+mlbUGF8trCYlTjMSH26mQMTNFJS4mQYUNzZYcTMNLm6mIcaNDWjcTMONm2nQcWODHjcTAeRmIobcWMPITWJw1k0CO+sm0Z01sUrFWROjU5w1sSjFWRMDUpw1sQ7FWZOqV5w1qWnFWZNqVJw1qSPFWdMqUZ01VbjqrKk6NWdNVAE7a6KRIWdNVDTorInSTM6aaG/QWRN9DjpromGTsyaqHnTWRPmDzppUh8lZ03oZdNa0oszOekG3jAurfn2HERj5rI7m/OvS7TKhe8aVraJ1XsC7u9junJblBYURZqduNSWba5SjK76RyyGP3n4gf4un0Y30rPjwwSEa6VRpV17yQyjykmygolE0P9SS8t9C6i7ocjNtV1LZcc1ATJjK5JsKWM9TNDKnBFWVqJ85EBtBgRcwUMoat2imn7qMCywbzmJWl/usvjj5yanfCvQxj6JnXdfS9RfBM+dELwNp+RiuzFHvs+Op2UnTufzzp66EbcgFqP3DNgo7A2DXkkjpqDzzQQohxz4iSIjd6RgJVsgPys7VACELIQziGK2jbXQAi9WdwzUXTKExFU0jg0Q5bo+HY1c4euJ3Lv8UC8ZDQF5LtD4aisWOEvcUSqQwFkkmAk3Gi06HVog4O+Vz4VtgTH+CLBAKEFwOcgDaXIgu2lQCkQLKOzxEEQp43uyA9Vz+KfBuQyBepxNChxAsBz+5bS6KRGEqjUJkEGIbelwIej58Lv0SmPMAkFFwNFkXO3VuLoxIYCqLTANK4B3cw4ZLQM4dz8UfAmf2G+QSnaITAstBD8ubiyHEm0ohkUDZoyM6ntZdfZRf5sK3VBf4J9jO18ftEbYrcry/rx54tLkWOgqwbe4Oh0OrvfBYx1/RXPolcOYBFzArGtsjrUhgklemASQ2dIyzBem6SXlx/z1i+y+/wMNfbpdIYUeqX+C32gVusAFYoh06IvUWZXngg0WzkUukn8n2Iwxa2E95pAQVhVAqQyxteCPQTB3p+EEw5/+J4x2B9Yihj8wN13MLv3Rz+E2w2NGVTcq/RFWRZ1X8FY9nzQfO2l3SDTvQyg9ttYdayd5p7Ijr/Hq8QCdecRBOfInJRsHuACwkyk9G9QOl2qw3xlKlPcfo/smlSqNRpdrtPGOpkvPvplTJeVSpPG+3MxarSX43xWqSnmJp5L8Xsc0yL055mZJLKcu8R8tsk+8xTI4ffXo+ZvbDzC+a7gKsxZLM7mdskq9c22G4psPYC6huPYmLfXcCHbyVF0WrKISP8hCAgm5jFv37bOEF1QyFFR79Ovm1nnd3L2px3GirY4lQNguzaPaxKNEJlZVTouh6RJGT5myrNP75fJOVKwhBYGhZ93tSnagpwgy4Iku/jFKtO3bo3UqvUhe3dQ/R6dQejXfl+yfxH3o4qL38fUm7Eh93TEoJ2sO9xbWGbg9n1wTkRXiM6zdy+klkgDUwNe1jiccn4ReMzaXgX0sURnmWvH2GBrh0ZNNxZJfI6tVIS0Mvt7aoUVk0csZYFssht3oZmzeFukkC+S6yOi9om+eN+4eZJ7R5DrZBJMoFLwO3IXiLQBUCd2a6HINSiAT6Gd2hPKsUyNMfzNSHc11sN3CuUt0USRhnNWpqs/uVruNYwvdxsGBV7/33I9k4GupfgetwmYBFM3NNRZKDk/Pcik6oBdPZKZVe7KC8xdaDuygaqt5/YKgm8FCjWqCb3DNuN2C+JBA+XDuUK8GPAUfxK79w+vMcisVZfG4vKpE7IvkkK46hd58Ct1TRaMA4haPb/JAwIR13GE87i0cOCHFG7Hxd+7PvdJ121qjjRO4MAc4xyQWSDypJZSIM+P3gnE14qPLkWkuH2EllKYcLTZzaDuQ/xSjqfpUD1Fq8enmWzBwblHoymVTF0Fshrlw7/NYEjfmsRy1VHdbx8QW6B4lxXXo+cI/X4muYxJFzQijCPkm6iUK+4kSxO/jsOb0XknOt8xy3FaDy2kuyf3PIjVL74EXK2XCjiuRIRJE8O8/Sh12QcdbKnXvrzXy9my92z+CY9r44Xqs6T/lN9DEZL8TKeEQIfg3ZZ0hue5VS72EaaWBCwhV4hKsZFoXdAwYLxCOHxTJQ6sKxITAkYu+gVlA2GdTCpflPxUTnA3TM6AzF17n1krXMhtWlc7ZPY8pG1/VgLuYkvDXK91PqQ1hLXcG0NiUhKScUB0jXW6bOTwpiqk7dkKPQYRgS3pS22JMnrMYe0n4t6rJZKdGUzKBDZq5c96qgSjSsS4jHvoeBqtMJMvBLTh6Wpbv2Vpv6bbwo2oaD4hn8Vj/5gMcBxbdzPD1Jp5jAnhgUer9qsGMIVMdydUTBZkhc0km9n7AW7G5a54fnbHj0MbftC8m1ZQazJ3G97a5LvTcl7R9Y2GXPL4qeLgXjIAvT3kLWJ4yhjfXQDjQwXVq71mVK19+0ADkVyxpfy0YGuj32GGCcve/MgN7/3vH9P29u4PvuPFiOnBuw4urDzDaid5RoopJGeYxIacpc4SaRTLMEJdpGPJuZgkQKito7VxCUD88VGP//1AwXmC9otMY5Qw/XQVK7uUNPDuPSWc0h7HPrTzZmLmGpQzO9/ZxiWvEMaUfMLdq042cXxqQ3pR335mtS7QC59TxjrGL7ko4cbLbpp884elmoep4kx7gRpBUraCHrFPrhzkJEow8cTjJq/jHaeQ0kn2Ya7zkTGcUSqqLV2l1HwyK/22xkBMMx8xFDfyuPV1U7HjVWNSfuH8jYimA/KxnkMWZeMtwGB+jt5yejW19f2jHzFNjmptT+tLmKapykz1EWYLpFMHL1cZm/zshCGPSQvJBe7MCEszc910eJieXXFEyLP/+4VnV8enP4NbwsGF5dksSi64VaEbvDl1YFtslJ3ZkkvQwhHPGEX7swMwRW3ZVLfMWU0pB3LsfRPSdUI51A5sqcWCtCWcG18OGluXbhs2dxDlyag1TB68W6AL1sDOua98WhzuCqV5+BEp4U4QqTHisgJgg/p/JNnvzU9qeJ+yembZkb2tlm2tKmjA2gTW//xC1xuEb1nXCHOuOTd/xJ9zODzwHh+IVAqjwANGr3GmbV7ePC3NpnI/kmrcU6oNKRu9h5NH2HqE37fFOeWQhl1vyhjzb9jBDcGLmDvqKsrrry8bNf/Xvc2XtR8iCFBkpc5IefTLzWu0jdx++6a/94lHgJmm/ZcyTFSu9M7S0/Sf0tS/X1zgcV0Ft3C35UwzrFnqeoLvnrT3Jx+JOfdX4+J2hQ6T5571uWPzgeJsi/B2rGphQ83WBZptVze9SvXxVss6WsivYBAZGPjTUH4dpfbxVuwSo4rH2Fm2jPXRbDJfXc7dzzNnPPh8qqWHXH2M6uRyjD3rIt0wC2LRRrjHVTfSulWKEgCA5TSrEHa2qahRtLNLnm6enPgTNJfCcKtNAlcLGxcN/bbpeqhXtog5YriZdk34z9cBmFNRilhKplM5Z2dm2tgBFWbZMCsmlenDEWTfWrKv24WS3d8fLvgZqZaM1wWabVc5yd8gEt0DeWFS2QwI6FjQ17y+1qt1YZeZtwe+gYiQZMGA+Xyl/OvbU/97YruViK7RJudoZrV2R7qx0mB0yWFmGUvRJdqmK7G3dzGin2Xq2FaZYKFWFihbLz3beB7ez8/W9ZBzRQYiQbrJEdcsOt66qHU5c75LoSO9FseQ4WBQ2CubdbzjdaORXb5SxV831cDfZGbJUCsOO2RLApG4tAtawU4bjeBYrqRxv0mILoNm0ozrTapif9+1t1u0gNYdMdExsPfNz6y+VSYXWIfI93aJSVaMyMuUXpOmxULp1iyoyhnSO2Lbu9FdskAIyYF2WMO6aKVbXteyc/Gi38Xq+SaeYLF2Ra/ZIj/sOuaHvanULVFZFAgY2tP/bRGqnMohC5KBCYiQZMuVuUb7Wd+6vd3A9cpYSKAVOG9p7Yrvj2FmxBDxgwK8lYH0w0q3V/0S46jRV+r9XJNAMGCzK1focvlliuluFKbcQ0sGNhNYNb+htfG5xFvuevOkay5y2/WJQr8OfBdr5eyYXSnG75xdLl2hV4jMMdIgfdLS7CqLEv0aQ2ZPdCLxop9l6tg6mOVi/CpOrkjxwrGDEHQ3sPdHaRcRqekbhUAeGnSlZ2QPIAJqvwFC1czW4S4Kjylw1fzUJtAxZahFVj3wBGpQTaglbAcZDzuOoZ3UKmlE5vLANlfMwyNEia462PNh0RotUys2k8g8CvxhVqPg/j2HoucCMy49oWGjWpaXxDmo5sAwUd05jGV9fk5vQo4j1Y0odtRUbAOdT7aJMS0WElK6tB1hDirPAEm9MjsLnK39CQDDC6hRZh1UxoRBOBdK2AYxrQ2OqZ3nweAtgHyviYZYiAO8eZH201IjQt5mOFyg9h3SJDqL08gNJLrOGmAqL2FnoDlDG+kUzC7eVCjZrDjKmKyW3jATy/r2gPmoCC73P8+tGWIULeSlaWiNMgkq6whZrIQysCKn+4nZhWCCwUCWtnfGuZukCgFXAkSDW2hia3nMcWDgaK+ZhxyAsJHDZ/tPWISLuck03PMgjeyyyhhvPI6oPCHW42htUICwWCWhnfaCauR6iFG9PNjKyXyc3loXWK/gI+ZhHSugXH5x/uaQRIX8rItp8ZWieQmEKN5aGVDpk73FjglQ8LBUJaGd9Upi18KAUb27eMqpXJTeWRBZHeAj5qDuICCV8ZeLSliIsJYj42fcrg6oTIEO5RJq6qSIxNnQmwymKhNUAVUzqSCesscqHGdCKjKuKBLmTy+ktf0SYZQBJnX27qMZSxywiYiWznrhusD8sX9ezDNYtQiQtgc2VnX27yWnjGjb8nPwNL8aRFd3KBZKEukGd6M2DYqfEEBDlPRS4RP9QZ43O+vduFmkIeVSrk0d08+i6XhWKW5LxSz9W7Lc0PArl4bwi50YOc5fq1fivQp8O1rvPsc0c9FyJLVKHaEFddD2ksRooHCxenMELiyRx2AoYe+sGlDctJV2ArbPnV12GEaNPFTfS5PW/jkit5k7CopGjx4pWWIs7OwOk2Vidue8X6/hJHEcrEo1KUZrZYBtW9dQZz8pWgU02/SvqMCv68FnpGd82LsEO6PUcV3U468Yzdwg8C/V00FsqP0T09ia+kLZYopSfLWstj12vycOjG3vZWYPab5g4m0YuH0qJ+44VUjgi2tCnKrn136bCLRvmVOp7ruvKtOqckD+s9JnsRngd1hRuPWevnKtwv2GW/7sxVj9DJwznhjCDhn8RVza7Sp8OSx2+hF99U8QLT7TyStmjF3fhFx0RB9AQptbyZolysSnIMlN/Tq1x+5CrHapl6AHb/BWbrTrBW3dQHzRYq5pD5ltQl6Mp2X8r2vmRaPUaVU8FEhatc30nnQ04BUie3MJN2oTSKptW6NqjOUuP4u0/hncNgr/gajy2LGle4ygp/F3uWO6OePNl1F6NquT2I/Vg1642mv77hioXLZd0R/NrQtxhSlNX/6xMV4PO8jwaz6acgxesnqfPi801os6zknVMl6aL4axyh8qZUQNu7qMMHoQKEV0fomw4C27hGPQ8mKYNLj44ujwkKy/0hry/auXZjD8ZfUQCOuVu+HiKJzCdMcqA0M/HW3tY7aDMTU9fJQBGJYTtTlbOhoeIE0zITvnNJzqSbfsjZTNqlItkZGY2qV5O0FBcURoJTl+6V51OWBfhIgz69kEXUK1kpM3RFv8HWRIMS5kFzYUrEnUHPpfnivfKGuzd0fsJEi0SQ30Am7C4Rb0abrIGRBHsA8fuheGEmDEWz5/dkafVMDXnBWQicb+0YWCjhDH/+oKipC9SqatZ9gqmEKHM1g5kCsQMcYDGMNPKjE+y1hKKhyqjzPDmEZe9TEuo9IyS6qsOylniYb2hR6youq9o5XuIkUns1mZJ+UhwqCXmaZ9C6NSqGV8ld6rPwFDXtwPmUQRmuKZF9kgnF6RNNJBOlwEU3CSHFaRNFpyqSuFbe51gEa196toaOuFiogUd7dZZ5kAkQAoN/icpiKCqnYsM4aYDmAhDSDzADjiwZolVFKc/7sBE4e4tDg8Z680zOlnlCWWo5tr0CaWhRXKIjv3fmmmbSVUZdUzTeBmRwEAOe46YiZ4DjNnqgnyw82U8WnkylkT0ZHiBiR6beotTLZ9CZKH3TOK8C+o7+Nm0hbZ+DgcQd5Wl0RyjKRMunZSoEiwMM7ZoxMMVMQErJ/VmHvPls4C7SYvlyE6Egxhj+hmQ0KwBeI8AUbo8Me3KfYWRd7AnNYzuosxVbd1WXqD5eJBRb4PyTeIveHIzhF6lJcdJ9b4ZBoccGhTzvD/odciZJfhgWSyIDZZQIRYH7ymmRs0LYlzcn7cldjOrLHKQbrBs5a2AAZ9IYdP+i+epGc9n5qNooIVvT4gPs5QSR2sQrOHF715vsh/uEUmknj/mG5BEd7aBA7zD+Myl36KpDc0pNVzNbC7FNrdyo+i510OUtKhXI/HE9O2FRoCySdOAUJcKBktqhVGygBSSdGSbkvDH4RnY/6DylWDGiRk0Nk6pUPVx10v4sxBICbOVoS1YW4vbQqiH9nrStXfkFRY2M6meAl4QWDbwNqN5SacauuvV4AcA0PG/BnrO1urbT+JLuqEegdQ0YRmR9ZGwEJi5FyHzxtMzYM5NYvbJ+0s3GRNhvmGoqZjIW/FtKzUr+Ke+bStni2bRZhTjWSoUmwn4VqqnMKjRS9qrwm75NK3VKetmFLnHMLHI+iq9a+qEhEsDOMBcen6y3qi3r2baS32UgYWPYE6waLIM4SDHM0scyget+JEcTtjAlYV8tjRh4KXdeDz0lnMaZ0FQ1ZI2GAU8zJKaHe6Uu34MTw48T84Gb472IO6ygBxzsXpqwuF3AwP+dH4ZQ73IG86SrMo8U6bCMNsYi8QXF/gdd+InwCSz6HvhgC89gzsY73zuYpDc7eAMX79DZw9bkB7jSjSN4AyDmr2NR4taGb3MBu37OBSEfrU0lp9PBdy64uH+jkwf7qxCLyb7EuFYAOhyesVGxQEGGBYH7YRa4H7rCsOErfLG+0L56Hosz8hjjH4adwkO5sEm7eqrgWiYfn6KwDvfk94/V1/MPTZq8HC9hWaH607U+becflj9XX8+zJk2y6tP3l7ou9j/++Pr6unhdLvLy/KPvui5O+f3sa4xe/zVvPn2Pfc52tv3+w/LPH5Y/F2F9mZ3iJPn0/Qd/eTqdvp9Fn77/Zb0I1qvFJkic5SLYzZaLtedjK1lu8d/BX93ZauGvZ/5it1nNNgs/mG1n/sLbLX/7/kfKGOf6Yfnnp2dbLWGnXqMyjbOwHnJvj9aIVV7/BfWymq3EeqnqMv+C5JpxZ/5lNVnJ3DVPtXzoHpqROT9Uzz35k2nsKF8hOhs49bt6iQey+CeborOaOSvBSRzj8pigWfnp++X3srMw2mFfYb+hEdLesm93ItmyJgMA8NyVIUTegiFFMmLUDwHBj7J0BfnGTiQAnTs9uUS9iD9z/0o8yW+pO8PufHlZ6a57xvYn0JLTbvvHbdHMPLdoZm1fP6PjzDHAVTs+wnO9sAyzIxKGR2qg8vsOLZ0oD5tt3UN0Or3YvaHi+du5t90ZrIny3+/xGO1rmFzb0TWrbHCLvcLj1/Sa1HGRoM/Kk6m/4qHPZzLPI5+fnrynz88cXpGeRpL2NYCHEFXBbTcHqgNvlpyUGDVFmEU3faZFiZwqtcKC2CZfeVNGu31XfStoE3xQ80nONrDduGw8X8iHrO4Mbg4c40pM85NuXa5vWWJUJnsXmAtbLEnCrWbMe0P2eYEP/rEsIT7aNFIUe8iEBT5JmJ0/ouy5R6R2TvOvZf5aoac7kCU8jeL7+l3tFNCYTsaqUzEc5Rm3XmBUwVDx2rWRdgVamS4yuVlJpxVRrYehZRIGPg2UHdsvlYEdqhJGKdkZ3fS97GyDU/+u83fpwogE6oNfUOx+z/OrkpjgfZdrengHdEnOA8tOQr4V/+qdGVORCXsnv3b+RdMirD8DyCHue2MGPXDxqHAMjFqdpzxl9w3frDOaomp1E866CudS1ROvNvrVT8kOJ+JnJwaRS5hHec0y3HE4dRlK54F5DYuHBsQGLT94Z0Tb+k6PqwYAGqvYvgz297s2Nhv/NsXS+jU1aElKgtFWJKT/PRpOZe2xtHN36vunNOT3bGPfwJwqazuqphpQ9e6WY3MPBo+gucoLcYJopzhJnCR/lYEk0EAH7JBwuhZFd+yAreIFRTNo/BBvwxPtwPY4Geb55xjjA8b3DgVjNpqFX3sPDikDV3VDk3ItAOFHb3vpPdlHKomT8i2q7e++F2050QLGIChBHR4qeT+/OJbna1uccka+yFlUuXh0L5hMRsqmzY2AVqMum/PRnmHrA59H6bmJ6lFiqKLkeS+dx8zaf+HS9qhw6qU5ujrJCdAuP6gIC/k4q8WMVG79s/Zfgo11Gcgn5dXjJlNOVGDeRZwkuiFAdahQtkchhTh631LLy2q3AKbGblKwWXmvv7ZJkKahJ4tiFCkJnUNYxbjg5Me5zF/3HsSjDg/8VNJP5EcRCvsvaNOUaFi9Ksd/s/DrISwfOE5heDadbIF0Dqh+RSgzOZtDWP60wCnCOEPlXA9yTsk1jnrd4VhZeMbOoQyF3cYS6CdDjJ4PY4ye9Nx8t71lYBeh+ei7LJrgZbqwAUeMCeH+QzvwNqEbYdyF1iYD1q72tr+YyHDJTlWHdXxkF+dIWUnbfM31A1ZOIJiYw69kEtsXGbKJTQza4M8FITsJS+1uLQ1khvaMWt1n0Ntv6b5MEEqxEh5qYSectPdCOvVpeCWxEx/zrHcNbhEIs5cFcEEJWzED95rI20h+xHU2I3+1C1J8xPYxDRs2LA42wWK3LZrnGxeWLmyQLa+aswEjmdsZsO4u7/amp2CzBjOmlkfu4yjz1xnbGd53BFzlMBObt9Kiy/y1P4Gx8XEEeCi5ocED2wPlljdV852PVzyjLl/buEWf9y9xWuRlHWb1i9Dm6bl5IyfezKU+FDCwzXoDG1ga9RRTipxsYJs1nPGjBpZGIw1MTjDawNTkDxrYaM0PGZgg34MGJnCyNbDdzoMNLDn3FFOKnGxgu50PZvyogSXnkQYmJxhtYGryBw1stOaHDEyQ70EDEzjZGpjn7XawhTVJTzmlyMkW5vmuC+b8qIk1yUgTkxOMNjE1+YMmNlr1QyYmyPegiQmcYBOT6R+syHG1+EgVvmf9mStvbKN5GajYd6rV/irlkQndFyZOQuc9ccp0BKIQb2UTLxzdPRsylStHTxhYJeyVTKY0SbixykgF8UQOy14OFKHpACgbYUUYa4i0uuSvfYQg/GVVRdyEoMqRUULpitkBdnR2+dBeWGm75BL//3uLXZbAxmwm94z9fxE8f8/iaLf26Xu/DcCz4GNYfPqeSN0Gp3GNyiRO4/rT9x7bnbmabS6+/8tq5gX0X3958X1gsy2sJ9TUYxoEOQ8cGkyARvY2E0Zi0YKjsPxi8Bp6lJInQKC+pQDnY3QUfhDM+X+idsyp+0QacBZSZhur3ECXIfHxe/kYHUdPlorf6KGU3IZOZwTNYYEBV6FUD+AwJArPoIrfq9fAQs+6v/7LfIesLMV1WDURxX8AcX3tBvAebP90WEZWKxAaiN3NKtyX17yM6KjpUKLwi4N/W16K3i5MDt2J7hsvRcdl+OmiLJO76i1qhGpBsHVyrFc88DsTwtmltsKVjo+tYWr5dgfN9Wy7uL4b2OScgZPHYt7OIY/elHUxjqZ7EmEd1wlSVn35ZX6EoLoeJBq6cW8J3u7BeaKmFksFUw0udLdUP3Sf0k0lcknYfbrtogE/ZOKD95CYjr4Qu3OXzy+mxXPVPqXcIRNi1UM2K7OVDGfmFc3zDAhyZ67E8AfBWmwNttXwKc9rs0ZsNSBfYW0oPs0KMOV2o7ALFVcPkkpPtzHIV9gs1lCFOvJ1M/TsLSdVnrOQsyBL0f15SNxY6jg9O9h2k/DNfoM3m2/CLTFOz+L2piHrEeSo8wJIqbounYXRjfXmRksDZAh5LXOmgAczZhsh4U0cc/ckUM9oJycbiRcUTc8iUpeVjKcQNEW5RylQbuwkIXr+msx7DzfxD6buVdvzpbotyf3hLFmexCnYq4jdizFRRzQzXUkAc7HMcDcgUP8gCcQPCgjHEYA0pk571K0qfUxnoreY25DyJtmzk8aCC/Wo1hmyVjmynLq/HnvXiZnjkOI0SkBvo3Mzag3MDVTaUJ55lryBfZzkzeEUQzrRKAd0MmI42p+PUW+gRMPGNm60Kmao3csD3zslCPYMiD2By5AmprM0Vvd0ll0tvDtbwdyUVkC7kOrGT4XQ384xv2b1fvmi/FSozmHRbtgBgvKyuIRZtfdeXuMof632npyp0qEazozewUTw7CY8HvMyivNspmktPzn1W4FEvfGgm+FttE5VFnxnlnMGgJvEyCTMhBu81XzEQk+7frtEYXQsr+nBZnd1OznRh/Ye3eI19PiafHpR8TKdMGTi9IMacIOWm4YS9b/YBC1qybuM2y1YPz5ZZEZmym2W8IxZSaNsLeb7w4vwHGckmVwzyqqYpnJQs0V4RmwVb+CeM3lPKjRf84pGOcXqB0NvpBpO6vI93614yisq/kv/A6pWRqbcFNXlJd8J7VvelaAexuz4jdsySNKp+MBMqClwgN0/tOjpwbvsxDFWl1v/4KTPZWk5MIMWuXeHwi12jysVx7eUd/y5UsUcBp+g5UeN6Oth1hv3xYZINpUITUlFbGw2vi4CmGOfJZjqfjlQ9UteL3BuIw0ByE0nkLKrUlBdoy5FhRlO0ZY/1FCM4k9qNoOthvZeYXTu75qwvrC6VuoFIdKtzBv1Vma7W5iVXceHsELi+9Bq/4yFpS8FKtsiDnU2Y2XROxh+moUxIFieuptkrW0mWXf640fm3E4KpyjjNCzf7E6jSEl+vZTo9Ll9xQuI0t6ot365bu0fjzy7Ch3zLBqUkff3SiJISjVyqpzBKjis/TbL6/GIqqpfSn8bblaBkgSUUYqaKqGHNmi54tnF2SnvF8/bhP5hK9JDsgnhkwXzNuH2wDN6Dcsszs43+UFHqHM5eu5GSQVJKEdJQoqvRQ7LGS13yHV5jlGYneXiAimOy6CrYZoCElGKmarGQ+R7y1Y8sp1iWIns8UkhDSSfGPGIAkPkIkEd5cDBN3q5mEgPK68Nn2yBke/5q/viH9f0kNdlnrUdq2+YmhkOu8NTMdKJm5FlPdcVzpV0ZoJMdjv69Gl0gkroTiir1UKv63FHnRwimZJZfteU2Wk0Hkm6eqW75XFRXKVxVcWHBCnlXQnsBarZ4pjklek+3m49ylBoUEClN3TdlbsNgDo/HlGgDXQP2yjEvaTEanaR3lFhpLvTMdJJRS21EvibwOeEWle43C6jFXAI7DvkoyUK1JH4OtpGB40ZLOJxezwcTzoxIKTv+kt/3ZLK/aAXBBt/BXmGFYq6K5Z4rku0Ph4UVrCABy86HTRSSIcHH3lLTih2gu4xWK2B1fHvIg8dT55avwgF6CDygQULD1GEXZ5AB0m19o/LViqlB9wG65ULKe10Oi2PkSLY6YTQIVRYwbKdTmgbeiopIF6wXJ7cVjy549v43hGs0tM22mhVegqOQpVSTgbhvIN72CiUgGyrned7m86pCL3e1tt6Wx8SDeE/qmjRKTohiREsGTqi42ktEwKCrbf4T1eArrPzDh7yoYZK2uRObQXr4/YYinwMTWB3OByQRAdZ2soN3OD+Rw5Rf0FvpzJMUTUryvxcoqpyDmHpVHUZF6i6nco8vUG3bnv0zrM6B2PdmXu///Eb8l5wjjKOJ95doz5LLsyKtdsubYBUsQw2p57h9zxf1MHJ+Dd9GKAjXOdBhhOzxbqSpWSajvQding+GpbOGRcRZfXHVRCh8xzY/xg8z/zgw1zo8LXfgfvBkNIcs1F4KL+ftWvcve4wv1TCMIvTsEZRuzBDA4gVVTNazFmcneIsrhFohi+jU9wXZCRnfhZKPG5CSMU9aXdhK9Pjh+fv6sYoJySpxT0q8vUa+sv4Jh58lG2IlcbaInP7J+8NnGXs3jh34ZdzKlzs0fi+gS+9KcQOctc3hn277ZU9Oyi1fX7vsEatFQQ0CfWddtAONGYt5Kzzs75jmGzqVfky+9EWPCbg4wLrU3KtLtpGxHbZst3wJuzZ0SdjKr8pu3JBPlN22ULuw3bSw+c3hvQjXcpAKsnVGEXi86hxzJWVQpON0DwVG8GBen72EzM+BzNyGKnGwXSSIo1i8dneWPZWquS5SqqkgUCOltNHPlM0pB+rxv5UkhKNIvEZ6TjmVirkeUoqpIF6flZTXD6bhRKPVF5fErkdm4ThU+YRnO0aMctQbsQkUM/Mfg5Op9uG9COVN5BK0l+fSGRaP465lQp5npIKaaCeny1OwCABOPlIBfYnkvRnFoghD6N4W6mPZympjwbq2VlCGQy1AFOPVF5vGtn2TOJwbGQMazvLYznKlkcCoZqyAFs4rgIlHm115iRyb2EShoM3IzjbdRUsQ7mrIIF3BpnT69DI+FXaZxGojxTry+HtQMilI/52ew+eG7n0BRf+gsQiYBmO3NJjkYZXiw2pMpR04SlrK/QmuB+udZ1nfH2BzR0HbvFvLzs23KF+X6R5FCZOXqDspgBVYtyMfrckTsPRrDbkjV24QAnbue8pblA0cBinna+5gfsi7j3QsDPhEQEqXBSHSX4GptoUdyD7gdgjIuxSC33zEOO1OIURmsl8BWyLfJ7yMp0tluwG3fxavwxSzLnqDQy0aMonCWv00Z07fvDh+aUnbsr9vabizmVsUb+nlyakF6pKeuovhGsqgfss16ND4UcUDT51LrzYSl/mcd0PM2f2ke5s/MPMfzax1raMSg98cGZfLwo34bY+zpiFTDvGKz7LIZtk3x425RBvdwXkwCleXzvDSzZ8ac0JZxCVeTG1/a6gcbTravyJ8YnPLinR2MRuosem8ex8qQXgaXk5q6efTRR2sMowfO8OPXhHnSz3TPHdwmr+3iHAsvi34E3BE8LaQ/2tEvPoDbBJw0lkQUp2VnWo6YGXGqEsApUqn1xtoVIxw5/0wxI3+T7/QBPyJ+04xU15FUBMUx3LPEkOYemkKKyuxudynd1utysa1jYDt2gXcsh32xlRfj0bKSTfKFzT6brtecI9f3pPrGfVC5q8HE9r5edAzwZyqFJB2CUWtu+6PJomEQu4pWkWdZ4ndVz0PG/tuRtXfYSbv/VFxnqnMI2Ttz0esCTIqd6qGqXzf03i7Msv4fHv5Oe/5Vk9f/o7Oudo9t//8jT/9/yQ1/n86b+h5Cuq42M4+xu6oqf5n8o4TOZVmFVOhcr4NH/6E2Y6+xm7p9mf0/wf8VPHRw/4+1t6yJOn+dPf8jqXUrFxKtugX6ZhIg1UV+pAdRGIyx7YusXf1HGB40BxVNsFdJ0qCUtQjbsR7OlwM2QCkTsiyPUQUohKJS34kSC6W5UkJC5D380LXj8hOHVmBoo337URs0VYlvkrYCbQW82LrfAqyILuv5EZ9byGLd61O/DSBK1O4rDui0PlsDwcrIRfG6dIwiNKUVb/r091XnyeiyQ17jn5qs6KvcY1yIJJr3Li2ukwcltO3VsMIMfuBAvp1eUHNojUTPYXfXGf9OW9chAHLKuFBHVTlhmrPAs2kGrYs51UOWwEIgjfWsh2ZCag1sTMWr0payy65hT90YGBtQZphcsqZMc9xxkXYwQpkUZxLbLFnBHMQGVJTIVnieV1QHZ5jagqZQHQWlO49mU94ZCRlkaYQDrCEVxDvMonGpqYB6g6Ia9WcfLanWhloPLI2FRUHecdZxl5zIb30uQy0hfwxEbvphBwZG/apJIXBOAw7YPUZg5rfTjQyotHVf//qOD/6FHBP2U+25rduIGF+NrYQtiCgf0HxJY9KjrXgo2jDznXB8YiLMe+sQgnwWMR5dR1wB1VPxvRFwrclPEImU8whOQHepXQH2aO92yfQatH+wSC59Qlg/gBox7Zn3bOj3Wn7yOJoe/rRlKSNQcPak3Twa0DM4BBHNms0pufMIjjRHQQJ03MLexJH8ZJ/KRhnMmiXoSqAl4FpG1/sPaUsZ6N6ZmHh1AhIJ7g8NFogHZmOFYqcDQhDknHmeKgHgGd3PhLxuCIeNgcxRExp2IjYuFKPBt7BIbEMkNxSDzRxakjZRtT6xldg/JBXE3Db3nU3VnayGIMiwRNK6Uh/ThLG9YjpJIbgxzhOYW1rc14786vCOkrP0zaP/gN3A/m0Yh86x0bmqujBh2wPm3wn4ECdpMmTkMmTTJ+amEf2rxJZCfPm76tZ5cnVzatzTgdA4oAcYRma4BXH9PaxokEAxHCDHBcSxvSoK4OlrXQzsTpJ2llcqO49d090g6ThHV/7TgcNIcg9t6zgHPAf/pvY1xaX8a4FC9FVJo8dG6+8xLRG1x8aWc5uTcpv1Yo0Vdvujg2mzcteJMFRW0hv0vcvy+dPnatL/kIvPlKL66MU3hEzte4ig9xEtdvfJG+J4qnLlBZFYjsG8FsCR6hBSlyOxlq6rkSVpToqxIGvvpoWKdfV8YIaN1+XU16LveRUgAPOluxM3U+UHolCLcRiKUSRCcEPSv//+MjvPCPw+9/rK5FkZd1Nfv4UePB5r1FiSpUfkXOMnqe5eXsYx8BqOhvVLJlRH0rWLw28n5nlQixV8XA0vYrEzc/gz5J1DdR6fsVYBkRMfvU1sabNGeqv37FOT2ac/7JqptSgmVExexTnSPqrmVPt/jI3r9dnxM8nxNdGa4oe0SnKPMClfXbnqXq523R5KBUphbYn4w7SF4eT5PNpgJ6KKkXEJYz35e94vNN6rTQnZ2efpeO+v9rmrTuGFrG/BF9RUIe3NeVd/uwxm7ZkYd1wYf+dR9p5ywkd7vvFYwkO10NRTOmJJF2t6h0N/uJWwxgTQpXWOuS8umUIZo8smIQdfBRYF/YTES+R73425fpQ6++DL/wMjvFSfLp+w/+8nQ6fS8/E7OdbcUXYKJP3/8SLPxg5ibOakb/eIvAwf/59L8Z+9dh4b8BT7eYlf87K6u/2JCyeosAl3MmlI988/CVQ/70ljXOovgY1nlZAa1d2XfpYftRF1AD2QkYWjx8iJtfdv9Budv+g/4kOiDwLIlN2w1dvt2QbynrGsGyu1m/VANI9vg3ae+4gFlNNucVzYu8Ld/wgob2sg8s9gBQ54iKHrj1uEWvcBJxq7ApZ4qi6Bm3x76/Ud68EzMcYe4aX1iQ8/sma8TWwa+gakXFgd2SvvRmvS/sOXDEhH1dz31BOzN+deHNcKVh9wAkT1HnhUpc54VOR59iV0lpqE7N1hxUKUgoIAMuDpxEiDKkgwrAwsUUh3N7Utp0olwgDwV61vVKQbSrZgdNNFI9nHbQprsSFTm748imexJVSdsUoqxdoCqtSg7FmCSmtyaqErNTv6YbEzV5Kb0kLQvSZJVI9XCTnPTuREVOcrTWdG+iKiQmFiUkv1XxBCIl0CgYuTtREYwfXjVdmqjKxuhF8XiQKqFMqoeb5KR3JypyshOipnsTVTEpuSglC1GFlAi1YJOI9P5ERUR6CtN0hYkqIaEWBaQBqnwimRpqVCC5O1FTYPkFoKX3JurqK7/Iyiu/AKpriZRAowWSuxNVC7zEtaGzUyiF3Tc6vRApJSPrBTfT3ec6qfKQiFUSikNI13vYJIMeCLFKSFYDxetDbBK5XAkuXOiWgF4cYipmR8bGvMaCdZR8FmwoSkdIR1MAWduDAlevAORCRyYl0DqxNgHvRyRyrQ/h5NSdyydlVVfOaVsPq9y9p3hXTs4dnXwDo+rkWvWJlmfyNx3r8otCqzX/VmraKhWZJV2T1ofg930AuuEXeoRHwvvvNoK4S21wMN3wjUdQHrYv+hjz6Stzl43YvG01NSqDY1weE6RUXOB+gGhd9bUVkeiYoLA8xQ2fLCm7KHEsHntfpDlP5OCJqrQSK/KMHDqJUrAaiITOs0BQRyaX6QCCOjwkXY7kF0DglPmrTIRDIMIjShKFEgfJpHgCbnglXyijRCWECcTmY26RU6VD6q5SG423VNZKr9JhvVfpsOo5jY32W1qrCqjSoTroSm1RDUA9bNZbVg/poNmnVpafjjb+1ML+U4smkI5oBemohpAOtoV0THPoOREZOcl5qB6Ss009tFTW9ZCch+shOQ/XA6exqYeW1qoekvNQPXSlnlYPHjnZQiqiSYYqoklsKqKlsq6IJhmuiCYZrghOY1MRLa1VRTTJUEV0pR5REUUZZzXWPfkYUj8lsqgBkdC6EmiiwXqgZINVIZDZ1IZIblUhNMFAnUh6sKmWBUoPeOiKqiLPqvgr9HoLuAGV3EnR3i+jbSZT2Rou1BAHZWqSmRZC1ivnOiEJAMJjcqEzEJEf/oGONRDxNY5QPryUKh0oldH19pnlvasXyfG9w9uuW1EQoO+Vv9gGG2/lb9cfgITe2pQwWC/8AEqyOrwtwRQbkNw7vHkgOXmvcUEucMB2rdxUohg2iaW3l6iUNFQjLvNXp0RfUUlud1J58yhDHqaUcqyW+LUM2bvI7QOHGg290VqgogEgL1mMlqcx/1OcJPKr/xrJGRfevbXf8qynI/EEEk8jqS5lnH3hfOgvgBMj8yQyiZuyVEjvT7mBt3yQqL60KIvglCiL+tLR5R4tKQ3uS8gudNFSSte99DEIyVTUkJ5G6is0ZHMFUxR8/4wpDVaQlgKZ82CK0fd0mBK0S2ViEvM6GS9JierjRUrDwvQksp1IYb0KEG0ESAUqQbEPOZlJEaptyKmMliEnZnYBpTVZRacYUZttWpM+K5ScyJ78m5NWzrmMI+I46Zqf7EBeuhR71bUIzMSaIbR91UJSdHXS0YMVQqhZbQDiqlUiCmyqLsJSMVuSwGy1rJRUzYAYmq5FOYCKIFcPUmSM3kKIP3UCigIK9xTqJGTUSynUMS8feuCKqONjNxShv0FSPlDTh24gOR/U6MMckJzc7aVc9WWQOD5+ES6V4jvgaLigZqFMcsx9QbjTG1L67hbTLgZYujwtvwNDTj58KdnSlTYxGkpBNy4qBXh+vi3olyy5nFQtNitSJ4Hv3u+LqnTyLHkDhqBssNltjvGE+xm0EfgLOSqPh0PsgI/7DL7X0Q5VWcYOWU3DUxD2sMEciKHP5iqmKV6myCQk361g5KBHgqhkdMOPdnPAfUFvKnCq9CY9wbvw2A0U9B/x5JK7CZ5FG6JplOTto9Xy+wdQSic5y4lJsqWWFsyWtm0hudrAXx0/YO9d+MEHOSZwb/wOMCVmw9Ns1DSe6wrPZ8hxpL/oqkWMvGAx+FZDmecFy9FeaaZEbdpUGzUVlkSYBsmRRBTBLMTYlJaiu8tDTZ5eWgJDBqnj3vh9DFJ47bjzRfrWRusri2lJSJqOBFhVTA8qH2hBMU1UVvpqYup4XFJ9dSStHY9k40lHlnW6ktA1HZ14o50iuMKR3/OgkyYqU+FmPbkI/k28LlUpgU/y87VD10oBfJKXDxwpVeRX+In3VCjiKyy7+wdk6Zdcek8XfkkyW4rCa1QloWo6qrI9k6qIrnATnilUJFcY0hV1TfBVKzik9xXJbCWJDil+RfJaKcJDmlc4cvEh1StMaQEA3Qe8CEu9AAHJLhALoFGVhKrpqNi+UF14hRsTXiNMVIZ0X6lCVjhud2GUFEEcTPHWxesepiAepmgEGsDFFAeNE+RjikRjpjuZwvGUx7YVmT2SkyfJDBASN1M0AqHJzxQHjafR0RSJxtbgaQrHl8/EKsXwSZa+XAygFD7JzldLARRC5WjyNkWiMYXdTeEspbtclRIsSX5LGXDTC7AkeS2VAmiEB42fweUUicYS9DmFs+qkh2pgRfJbyfJDVbAi2a3UEkB1oPI0+p0i0dgaHE/hBG05tLZNPE/x1pGArqcgrqdoBDLY9xQHjZ/B+RSJxhL0PikdPjHPqQ2fahJN3J1ARwqh0ZactpFoS3hgdoA5s+Jo5AnMnJRJJSb7lNM8y8nw/yZe3Pb3f/slz3Ln39H5moTl/BeUJfn8lzwLj/n85zyr8iSs5k9/jQ+InvCZYfKn+dPP+bWMUTn7G3p9mresWVYMu7sJ28dZkCYVQ3716ZJGWZfX7BjWSL0Vn25SbwNRksRFFVfADIwxIqiCcr+blhtFFgQqDV4gcQx40fbJC4Tm3RoUBEptkf4qHQf2U85T8P42p4mQf5Vaof5kr4od8M84jsX+q9QG/q9SmxUATjWwCJBarwOkU5YC0odWA6p08oIAtompawJV+viyQJU+tDKQTlocYPoasz7Q6cl+iQDrZ9IqQTpxoSCdvFYgacR+uUDViu2KgWA5kxYNOquZtG6g6tdu6aBK33n1IJ2wgCBVlM0aQldF77mMoJu21UpC+v6LCVU6vJ5QpTZLCnyPJbyqkOJ4I0KG48gYTyACcTJG2EiEMFoG8jRgZiBbCDmrhsAzTMBzHYbQGHUjUfcAaSD3PjgNzMAIqlUDuBqO59kPomuMuJGIzRgbyLsHaQPZm/C2qh9yw9E87yHgjdE2Eq0RfgM5m0E4kLkBiquG0DhMwPMexuQYdSNR9yBzIPc+fA7MwIjSVf1AHY7muQ/BdYy2kWiNoB3I2QzdgcwNAB5xLiYMj7qg4k2iApE8RtnIlDCeB3M1oHowYwjbI96kF96jjqd4k0jNIB8jb2TyHqgP5t8H+MFZGGE/4lb6kD/qgIo3idKI/zHqRqY2o4Aw9x4sEM7AhAgS/9IDClJHVLxJhCZokBE3MrERIIR5m2FCmL0BLCTOpRcvpH6oeJNIzaghI29k8h7sEObfhyDCWRhxROJpeqBE6pKKN4nQBCgy4kYmNsKKMG8zuAizN0CM1SDKyCi4f7bAGrsUjZrCiDj25GLGHXsyMqOPfPQ9hLu1I/BB6K2br/Shbz2HdMh8KI1s4bc0Gge/Uc5T4Lc2p4nwWxpZwW/kiJId/MY4joXf0sgGfksjG/iNU/XDb2lkC791lCPgN5zoAfgtjSbDb9gmpsJvafQ4/JZGj8Bvrd7GwW9MX2Pgt05P9vAb1s8U+I2UagL8pmhjDPwmacQeflO1Ygu/CZYzCX7rrGYK/Kbp1w5+w5m+J/ymVJcd/CZVlA381lXRe8JvumnbwG+C4t8NfkujYfgtjWzgN3601gS/pZEZfsNxZLQjEIHwGyNsJEIYfgN5GuA3kC0Ev6XRAPyGCXiuw/Abo24k6h74DeTeB7+BGRjhtzTqh99wPM9+EH5jxI1EbIbfQN498BvI3gS/pVEv/Iajed5D8BujbSRaI/wGcjbDbyBzA/yWRgPwGybgeQ/Db4y6kah74DeQex/8BmZghN/SqBd+w9E89yH4jdE2Eq0RfgM5m+E3kLkBfiPOxQS/URdUvElUIPzGKBuZEobfYK4G+A1mDMFvxJv0wm/U8RRvEqkZfmPkjUzeA7/B/PvgNzgLI/xG3Eof/EYdUPEmURrhN0bdyNRm+A3m3gO/wRmY4DfiX3rgN+qIijeJ0AS/MeJGJjbCbzBvM/wGszfAb8S59MJv1A8VbxKpGX5j5I1M3gO/wfz74Dc4CyP8RjxND/xGXVLxJhGa4DdG3MjERvgN5m2G32D2BviNzxDM8Buj4P7ZAn7rUjRqCiP81pOLGX7ryahn819kB7+1I/BB+K2br4yE3/jdLGQ+lJxt4bfkPA5+o5ynwG9tThPht+RsBb+Rm2ns4DfGcSz8lpxt4LfkbAO/cap++C0528JvHeUI+A0negB+S86T4TdsE1Pht+T8OPyWnB+B31q9jYPfmL7GwG+dnuzhN6yfKfAbKdUE+E3Rxhj4TdKIPfymasUWfhMsZxL81lnNFPhN068d/IYzfU/4TakuO/hNqigb+K2roveE33TTtoHfBMW/31H68zD8lpxt4Dd+o5oJfkvOZvgNx5HRjkAEwm+MsJEIYfgN5GmA30C2EPyWnAfgN0zAcx2G3xh1I1H3wG8g9z74DczACL8l5374Dcfz7AfhN0bcSMRm+A3k3QO/gexN8Fty7oXfcDTPewh+Y7SNRGuE30DOZvgNZG6A35LzAPyGCXjew/Abo24k6h74DeTeB7+BGRjht+TcC7/haJ77EPzGaBuJ1gi/gZzN8BvI3AC/Eedigt+oCyreJCoQfmOUjUwJw28wVwP8BjOG4DfiTXrhN+p4ijeJ1Ay/MfJGJu+B32D+ffAbnIURfiNupQ9+ow6oeJMojfAbo25kajP8BnPvgd/gDEzwG/EvPfAbdUTFm0Rogt8YcSMTG+E3mLcZfoPZG+A34lx64Tfqh4o3idQMvzHyRibvgd9g/n3wG5yFEX4jnqYHfqMuqXiTCE3wGyNuZGIj/AbzNsNvMHsD/MZnCGb4jVFw/2wBv3UpGjWFEX7rycUMv/VkZIbf+Oh7CH5rR+CD8Fs3XxkJv7VX8pIJUZPY4m9NMg5/o5yn4G9tThPxtyaxwt/IhcR2+BvjOBZ/axIb/K1JbPA3TtWPvzWJLf7WUY7A33CiB/C3JpmMv2GbmIq/Ncnj+FuTPIK/tXobh78xfY3B3zo92eNvWD9T8DdSqgn4m6KNMfibpBF7/E3Vii3+JljOJPyts5op+JumXzv8rUneF39TqssOf5MqygZ/66roPfE33bRt8DdB8e+GvzXJMP6Gu8xh/I1fpG/C35rEjL81CcPKBCIQf2v47WoiIYy/gTwN+BvIFsLfmmQAf2sShpAJlGb8reHXrYnUPfgbyL0PfwMzMOJvTdKPvzUJw8gEQiP+1vC72ERiM/4G8u7B30D2JvytSXrxtyZhKJlAZ8LfGn5Rm0hrxN9Azmb8DWRuwN+aZAB/axKGkAmUZvyt4fe3idQ9+BvIvQ9/AzMw4m9N0ou/NQlDyQQ6E/7W8OvdRFoj/gZyNuNvIHMD/kaciwl/oy6oeJOoQPyt4be/SZQw/gZzNeBvMGMIfyPepBd/o46neJNIzfhbw6+Dk8h78DeYfx/+BmdhxN+IW+nD36gDKt4kSiP+1vC74iRqM/4Gc+/B3+AMTPgb8S89+Bt1RMWbRGjC3xp+kZxEbMTfYN5m/A1mb8DfiHPpxd+oHyreJFIz/tbw++Uk8h78Debfh7/BWRjxN+JpevA36pKKN4nQhL81/Po5idiIv8G8zfgbzN6Av/EZghl/a5IOGZOpTfhbI9xHp6Qw4m89uZjxt56MzPgbH30P4W/tCHwQf+vmK734GwPr8ldUHsMK3dhNdmFWnfIy3bcRGv9rUcBJ2ggtyTEs4jpM4t+0NF2MNJ3Is9p5JXc8s4dFhZD9Un6TWSSm14dL1Csz9SFPIol2A9AS8Y6UrKrfErSnIVoh6UOl8AulhIA/HWt+cV0ka189lgLpg8bGp9Pp8eP2zVnzi+kyoZyX+gK68dlzSs0erDW/di6SKTlJL5gbny0ntOSlW/Nr5S2NnIPwDrnx8XFae+xxXPOb4yKZnIn8jrjx8XBCy17VNb8ZLlDJuUgvgRuf/6atmrQZ86vfHZGchfiat/EJbyZM+eVmfrm7pVGL0L7JbXyImxAe8qi1Xt/zA3+nkaTXGkVGC2dskvD4xQlcRibe2y/f2t81YIXaD4I5/w9Kc4kjemvp3v3RnYUv2hPg9A5Q4RWAl74Hw4WXGNg7CTfyb5zE9Rt/OkEUIs4AOnr7qEAmvbr3hzl7JHfevvOlyiggSOY3DMJ9ltcfF4c6e6YMInTM6VWs+2sWoTKJM3QPD4fy1zquE/SZv83bvvY2+/g0C+u6/Ejin2dPz0/3okTSlatFiRxl5YO8Gfe/r3mN5phaf1E9jA7BIXopwjNyDiUKvzhxVsUR2odf8zi61xcURspDezgIlQ6ul+Iep+d5Xd5M6S/+/LKcF7e8LC5hVu2XL69xlL9W+yWNEhOSErN0f8Thtyr+De3D5X2B1RDGGSrnxNqVbehiJWfh10NYSg8k3heHMDpDhXdd976gzxR2j2YnYVGhPf+QrBhTzupozr8uwy/gU5VR7ijqEgtBF6uH7mkqwZfE2QWVsRQzq7F6fiB/z6XwSP55UX6iUJCjfb+cyMCLvSBUPIEswwuY8L44X500Lsu8ND6G86JDnO37LrvdTnBlL3kRHnGLXWxfnLRyTnGCzeWpKPNzHO3/7//xlzQ8o//go6XFL/GxzKv8VC/+lBSX8OP/Q5N/2rrPTy8scUhi8i7mpchjPPhz0FeU1RUzn/OV+i4yMnWwWLLNna/ONatQgo7UlvgrNteKvGqPw1VX4aT5b/3xVV+0OYpIQ7xkXN9alfkPqcw3qsx3n+8LprPb8VpWeblnP3nDkqcCgesWzX2R5lGYONVFePSTvm6ptSfSs3grd87/W6yf7/9vAAAA///XLRNNcQ0CAA==\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/frontend b/frontend index d9bbbb5..561b58e 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit d9bbbb5a4776254abf2316364d368aac0d5e92ad +Subproject commit 561b58eaee6722bc276d779f178c16f4042d6e8d From c4085a6675a5ec51a3f7607213e10f6f1e275a15 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 18:24:23 -0400 Subject: [PATCH 079/182] adding fix for when you first initial a new guide source --- api/guide_source.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/api/guide_source.go b/api/guide_source.go index d0c56a7..435880f 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -25,6 +25,8 @@ func addGuide(cc *context.CContext, c *gin.Context) { return } + cc.GuideSourceProviders[newGuide.ID] = provider + log.Infoln("Detected passed config is for provider", provider.Name()) channels, channelsErr := provider.Channels() From e56d258569524495852380896f93c4b6382a35d1 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 18:25:04 -0400 Subject: [PATCH 080/182] adding a context update for when you add a new video source --- api/video_source.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/api/video_source.go b/api/video_source.go index ca5093d..98c4325 100644 --- a/api/video_source.go +++ b/api/video_source.go @@ -36,6 +36,8 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { return } + cc.VideoSourceProviders[newProvider.ID] = provider + log.Infoln("Detected passed config is for provider", provider.Name()) channels, channelsErr := provider.Channels() From b70d47f875ba32b0b765678affca9735c9cb6742 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:22:37 -0400 Subject: [PATCH 081/182] adding new command directory --- commands/guide_updates.go | 1 + commands/video_updates.go | 1 + 2 files changed, 2 insertions(+) create mode 100644 commands/guide_updates.go create mode 100644 commands/video_updates.go diff --git a/commands/guide_updates.go b/commands/guide_updates.go new file mode 100644 index 0000000..cdff10d --- /dev/null +++ b/commands/guide_updates.go @@ -0,0 +1 @@ +package commands diff --git a/commands/video_updates.go b/commands/video_updates.go new file mode 100644 index 0000000..cdff10d --- /dev/null +++ b/commands/video_updates.go @@ -0,0 +1 @@ +package commands From 774e84672d8d8cec4939aa075acbc966afb32765 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:40:36 -0400 Subject: [PATCH 082/182] adding scaffold for the guide update command --- commands/guide_updates.go | 47 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 47 insertions(+) diff --git a/commands/guide_updates.go b/commands/guide_updates.go index cdff10d..f43a467 100644 --- a/commands/guide_updates.go +++ b/commands/guide_updates.go @@ -1 +1,48 @@ package commands + +import ( + "os" + + "github.com/sirupsen/logrus" + "github.com/tellytv/telly/context" + ginprometheus "github.com/zsais/go-gin-prometheus" +) + +var ( + log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } + + prom = ginprometheus.NewPrometheus("http") +) + +// FireGuideUpdatesCommand Command to fire one off video source updates +func FireGuideUpdatesCommand() { + cc, err := context.NewCContext() + if err != nil { + log.Fatalln("Couldn't create context", err) + } + if err = fireGuideUpdates(cc); err != nil { + log.Errorln("Could not complete guide updates " + err.Error()) + } +} + +func fireGuideUpdates(cc *context.CContext) error { + + return nil +} + +// StartFireGuideUpdates Scheduler triggered function to update guide sources +func StartFireGuideUpdates(cc *context.CContext) { + err := fireVideoUpdates(cc) + if err != nil { + log.Errorln("Could not complete video updates " + err.Error()) + } + + log.Infoln("Video source has been updated successfully") +} From 6c39bce1b4f39a5e31639d1f7a33c0b1fc44d76a Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:40:48 -0400 Subject: [PATCH 083/182] adding scaffold for the video source update --- commands/video_updates.go | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/commands/video_updates.go b/commands/video_updates.go index cdff10d..8770457 100644 --- a/commands/video_updates.go +++ b/commands/video_updates.go @@ -1 +1,31 @@ package commands + +import ( + "github.com/tellytv/telly/context" +) + +// FireVideoUpdatesCommand Command to fire one off video source updates +func FireVideoUpdatesCommand() { + cc, err := context.NewCContext() + if err != nil { + log.Fatalln("Couldn't create context", err) + } + if err = fireVideoUpdates(cc); err != nil { + log.Errorln("Could not complete video updates " + err.Error()) + } +} + +// +func fireVideoUpdates(cc *context.CContext) error { + return nil +} + +// StartFireVideoUpdates Scheduler triggered function to update video sources +func StartFireVideoUpdates(cc *context.CContext) { + err := fireVideoUpdates(cc) + if err != nil { + log.Errorln("Could not complete video updates " + err.Error()) + } + + log.Infoln("Video source has been updated successfully") +} From 4064aa6123098b9127e5ef3c7d29bb5293c82d22 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:46:02 -0400 Subject: [PATCH 084/182] removing gin prometheus --- commands/guide_updates.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/commands/guide_updates.go b/commands/guide_updates.go index f43a467..5fb2f47 100644 --- a/commands/guide_updates.go +++ b/commands/guide_updates.go @@ -5,7 +5,6 @@ import ( "github.com/sirupsen/logrus" "github.com/tellytv/telly/context" - ginprometheus "github.com/zsais/go-gin-prometheus" ) var ( @@ -17,8 +16,6 @@ var ( Hooks: make(logrus.LevelHooks), Level: logrus.DebugLevel, } - - prom = ginprometheus.NewPrometheus("http") ) // FireGuideUpdatesCommand Command to fire one off video source updates From c6c34a70e200f210da9e36957109c598b2b1cd5e Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:46:25 -0400 Subject: [PATCH 085/182] adding new cron lock --- Gopkg.lock | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Gopkg.lock b/Gopkg.lock index 3ad16d2..c922667 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -246,6 +246,14 @@ pruneopts = "UT" revision = "05ee40e3a273f7245e8777337fc7b46e533a9a92" +[[projects]] + digest = "1:ed615c5430ecabbb0fb7629a182da65ecee6523900ac1ac932520860878ffcad" + name = "github.com/robfig/cron" + packages = ["."] + pruneopts = "UT" + revision = "b41be1df696709bb6395fe435af20370037c0b4c" + version = "v1.1" + [[projects]] digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc" name = "github.com/sirupsen/logrus" @@ -423,6 +431,7 @@ "github.com/pressly/goose", "github.com/prometheus/client_golang/prometheus", "github.com/prometheus/common/version", + "github.com/robfig/cron", "github.com/sirupsen/logrus", "github.com/spf13/pflag", "github.com/spf13/viper", From 21de86924eb4a166590c56eacf9bd07e9fc7214d Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:46:40 -0400 Subject: [PATCH 086/182] adding two cron jobs --- main.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/main.go b/main.go index 5bc113a..3a914eb 100644 --- a/main.go +++ b/main.go @@ -9,10 +9,12 @@ import ( "regexp" "github.com/prometheus/common/version" + "github.com/robfig/cron" "github.com/sirupsen/logrus" flag "github.com/spf13/pflag" "github.com/spf13/viper" "github.com/tellytv/telly/api" + "github.com/tellytv/telly/commands" "github.com/tellytv/telly/context" "github.com/tellytv/telly/utils" ) @@ -110,6 +112,11 @@ func main() { api.StartTuner(cc, &lineup) } + c := cron.New() + + c.AddFunc("@daily", func() { commands.StartFireVideoUpdates(cc) }) + c.AddFunc("@daily", func() { commands.StartFireGuideUpdates(cc) }) + api.ServeAPI(cc) } From 0efc30be369d579e5c999b82dbdb281654d87c6f Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Mon, 27 Aug 2018 19:52:25 -0400 Subject: [PATCH 087/182] adding a run command --- Makefile | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/Makefile b/Makefile index 437f729..db0c78e 100644 --- a/Makefile +++ b/Makefile @@ -45,3 +45,7 @@ promu: .PHONY: all style format build test vet tarball docker promu + + +run: + go run *.go \ No newline at end of file From ab0d754f774cee727d58931210cadc7a66999170 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 16:54:54 -0700 Subject: [PATCH 088/182] Add provider specific data field to guide for SD cache implementation --- api/guide_source.go | 4 +-- api/tuner.go | 2 +- main.go | 7 ----- migrations/00001_init.sql | 17 ++++++----- models/guide_source.go | 33 ++++++++++++++-------- models/guide_source_channel.go | 38 +++++++++++++++---------- models/guide_source_programme.go | 48 +++++++++++++++++++------------- 7 files changed, 86 insertions(+), 63 deletions(-) diff --git a/api/guide_source.go b/api/guide_source.go index 435880f..6980452 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -11,7 +11,7 @@ import ( func addGuide(cc *context.CContext, c *gin.Context) { var payload models.GuideSource if c.BindJSON(&payload) == nil { - newGuide, providerErr := cc.API.GuideSource.InsertGuideSource(payload) + newGuide, providerErr := cc.API.GuideSource.InsertGuideSource(payload, nil) if providerErr != nil { c.AbortWithError(http.StatusInternalServerError, providerErr) return @@ -37,7 +37,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { } for _, channel := range channels { - newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(newGuide.ID, channel) + newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(newGuide.ID, channel, nil) if newChannelErr != nil { log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") c.AbortWithError(http.StatusInternalServerError, newChannelErr) diff --git a/api/tuner.go b/api/tuner.go index 25c5b5d..1e9c45e 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -56,7 +56,7 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { } for _, programme := range schedule { - _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(guideSource.ID, programme) + _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(guideSource.ID, programme, nil) if programmeErr != nil { log.WithError(programmeErr).Errorln("error while inserting programmes") return diff --git a/main.go b/main.go index 5bc113a..591dd43 100644 --- a/main.go +++ b/main.go @@ -6,7 +6,6 @@ import ( "fmt" "net" "os" - "regexp" "github.com/prometheus/common/version" "github.com/sirupsen/logrus" @@ -114,12 +113,6 @@ func main() { } func validateConfig() { - if viper.IsSet("filter.regexstr") { - if _, regexErr := regexp.Compile(viper.GetString("filter.regex")); regexErr != nil { - log.WithError(regexErr).Panicln("Error when compiling regex, is it valid?") - } - } - var addrErr error if _, addrErr = net.ResolveTCPAddr("tcp", viper.GetString("web.listenaddress")); addrErr != nil { log.WithError(addrErr).Panic("Error when parsing Listen address, please check the address and try again.") diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql index a53726b..79fe1df 100644 --- a/migrations/00001_init.sql +++ b/migrations/00001_init.sql @@ -28,19 +28,21 @@ CREATE TABLE IF NOT EXISTS video_source_track ( ); CREATE TABLE IF NOT EXISTS guide_source ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT, - provider VARCHAR(64) NULL, - username VARCHAR(64) NULL, - password VARCHAR(64) NULL, - xmltv_url TEXT, - imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + provider VARCHAR(64) NULL, + username VARCHAR(64) NULL, + password VARCHAR(64) NULL, + xmltv_url TEXT, + provider_data TEXT, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE IF NOT EXISTS guide_source_channel ( id INTEGER PRIMARY KEY AUTOINCREMENT, guide_id INTEGER, xmltv_id TEXT, + provider_data TEXT, data TEXT, imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, @@ -54,6 +56,7 @@ CREATE TABLE IF NOT EXISTS guide_source_programme ( start TIMESTAMP, end TIMESTAMP, date DATE, + provider_data TEXT, data TEXT, imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP, diff --git a/models/guide_source.go b/models/guide_source.go index 28e6fc9..ae7c984 100644 --- a/models/guide_source.go +++ b/models/guide_source.go @@ -1,6 +1,7 @@ package models import ( + "encoding/json" "fmt" "time" @@ -31,13 +32,14 @@ func (db *GuideSourceDB) tableName() string { // GuideSource describes a source of EPG data. type GuideSource struct { - ID int `db:"id"` - Name string `db:"name"` - Provider string `db:"provider"` - Username string `db:"username"` - Password string `db:"password"` - URL string `db:"xmltv_url"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + Name string `db:"name"` + Provider string `db:"provider"` + Username string `db:"username"` + Password string `db:"password"` + URL string `db:"xmltv_url"` + ProviderData json.RawMessage `db:"provider_data"` + ImportedAt *time.Time `db:"imported_at"` Channels []GuideSourceChannel `db:"-"` } @@ -55,7 +57,7 @@ func (g *GuideSource) ProviderConfiguration() *guideproviders.Configuration { // GuideSourceAPI contains all methods for the User struct type GuideSourceAPI interface { - InsertGuideSource(guideSourceStruct GuideSource) (*GuideSource, error) + InsertGuideSource(guideSourceStruct GuideSource, providerData interface{}) (*GuideSource, error) DeleteGuideSource(guideSourceID int) (*GuideSource, error) UpdateGuideSource(guideSourceID int, description string) (*GuideSource, error) GetGuideSourceByID(id int) (*GuideSource, error) @@ -71,15 +73,24 @@ SELECT G.username, G.password, G.xmltv_url, + G.provider_data, G.imported_at FROM guide_source G` // InsertGuideSource inserts a new GuideSource into the database. -func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource) (*GuideSource, error) { +func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource, providerData interface{}) (*GuideSource, error) { guideSource := GuideSource{} + + providerDataJSON, providerDataJSONErr := json.Marshal(providerData) + if providerDataJSONErr != nil { + return nil, fmt.Errorf("error when marshalling providerData for use in guide_source_programme insert: %s", providerDataJSONErr) + } + + guideSourceStruct.ProviderData = providerDataJSON + res, err := db.SQL.NamedExec(` - INSERT INTO guide_source (name, provider, username, password, xmltv_url) - VALUES (:name, :provider, :username, :password, :xmltv_url);`, guideSourceStruct) + INSERT INTO guide_source (name, provider, username, password, xmltv_url, provider_data) + VALUES (:name, :provider, :username, :password, :xmltv_url, :provider_data);`, guideSourceStruct) if err != nil { return &guideSource, err } diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index 5ee9379..148af04 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -33,11 +33,12 @@ func (db *GuideSourceChannelDB) tableName() string { // GuideSourceChannel is a single channel in a guide providers lineup. type GuideSourceChannel struct { - ID int `db:"id"` - GuideID int `db:"guide_id"` - XMLTVID string `db:"xmltv_id"` - Data json.RawMessage `db:"data"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + GuideID int `db:"guide_id"` + XMLTVID string `db:"xmltv_id"` + ProviderData json.RawMessage `db:"provider_data"` + Data json.RawMessage `db:"data"` + ImportedAt *time.Time `db:"imported_at"` GuideSource *GuideSource GuideSourceName string @@ -46,7 +47,7 @@ type GuideSourceChannel struct { // GuideSourceChannelAPI contains all methods for the User struct type GuideSourceChannelAPI interface { - InsertGuideSourceChannel(guideID int, channel guideproviders.Channel) (*GuideSourceChannel, error) + InsertGuideSourceChannel(guideID int, channel guideproviders.Channel, providerData interface{}) (*GuideSourceChannel, error) DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) @@ -58,26 +59,33 @@ SELECT G.id, G.guide_id, G.xmltv_id, + G.provider_data, G.data, G.imported_at FROM guide_source_channel G` // InsertGuideSourceChannel inserts a new GuideSourceChannel into the database. -func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel guideproviders.Channel) (*GuideSourceChannel, error) { - marshalled, marshalErr := json.Marshal(channel) - if marshalErr != nil { - return nil, marshalErr +func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel guideproviders.Channel, providerData interface{}) (*GuideSourceChannel, error) { + channelJSON, channelJSONErr := json.Marshal(channel) + if channelJSONErr != nil { + return nil, fmt.Errorf("error when marshalling guideproviders.Channel for use in guide_source_channel insert: %s", channelJSONErr) + } + + providerDataJSON, providerDataJSONErr := json.Marshal(providerData) + if providerDataJSONErr != nil { + return nil, fmt.Errorf("error when marshalling providerData for use in guide_source_programme insert: %s", providerDataJSONErr) } insertingChannel := GuideSourceChannel{ - GuideID: guideID, - XMLTVID: channel.ID, - Data: marshalled, + GuideID: guideID, + XMLTVID: channel.ID, + Data: channelJSON, + ProviderData: providerDataJSON, } res, err := db.SQL.NamedExec(` - INSERT INTO guide_source_channel (guide_id, xmltv_id, data) - VALUES (:guide_id, :xmltv_id, :data)`, insertingChannel) + INSERT INTO guide_source_channel (guide_id, xmltv_id, data, provider_data) + VALUES (:guide_id, :xmltv_id, :data, :provider_data)`, insertingChannel) if err != nil { return nil, err } diff --git a/models/guide_source_programme.go b/models/guide_source_programme.go index 195ddc2..af615aa 100644 --- a/models/guide_source_programme.go +++ b/models/guide_source_programme.go @@ -33,20 +33,21 @@ func (db *GuideSourceProgrammeDB) tableName() string { // GuideSourceProgramme is a single programme available in a guide providers lineup. type GuideSourceProgramme struct { - GuideID int `db:"guide_id"` - Channel string `db:"channel"` - StartTime *time.Time `db:"start"` - EndTime *time.Time `db:"end"` - Date *time.Time `db:"date,omitempty"` - Data json.RawMessage `db:"data"` - ImportedAt *time.Time `db:"imported_at"` + GuideID int `db:"guide_id"` + Channel string `db:"channel"` + ProviderData json.RawMessage `db:"provider_data"` + StartTime *time.Time `db:"start"` + EndTime *time.Time `db:"end"` + Date *time.Time `db:"date,omitempty"` + Data json.RawMessage `db:"data"` + ImportedAt *time.Time `db:"imported_at"` XMLTV *xmltv.Programme `json:"-"` } // GuideSourceProgrammeAPI contains all methods for the User struct type GuideSourceProgrammeAPI interface { - InsertGuideSourceProgramme(guideID int, programme xmltv.Programme) (*GuideSourceProgramme, error) + InsertGuideSourceProgramme(guideID int, programme xmltv.Programme, providerData interface{}) (*GuideSourceProgramme, error) DeleteGuideSourceProgramme(channelID int) (*GuideSourceProgramme, error) UpdateGuideSourceProgramme(channelID int, description string) (*GuideSourceProgramme, error) GetGuideSourceProgrammeByID(id int) (*GuideSourceProgramme, error) @@ -59,6 +60,7 @@ const baseGuideSourceProgrammeQuery string = ` SELECT G.guide_id, G.channel, + G.provider_data, G.start, G.end, G.date, @@ -67,25 +69,31 @@ SELECT FROM guide_source_programme G` // InsertGuideSourceProgramme inserts a new GuideSourceProgramme into the database. -func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, programme xmltv.Programme) (*GuideSourceProgramme, error) { - marshalled, marshalErr := json.Marshal(programme) - if marshalErr != nil { - return nil, fmt.Errorf("error when marshalling xmltv.Programme for use in guide_source_programme insert: %s", marshalErr) +func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, programme xmltv.Programme, providerData interface{}) (*GuideSourceProgramme, error) { + programmeJSON, programmeMarshalErr := json.Marshal(programme) + if programmeMarshalErr != nil { + return nil, fmt.Errorf("error when marshalling xmltv.Programme for use in guide_source_programme insert: %s", programmeMarshalErr) + } + + providerDataJSON, providerDataJSONErr := json.Marshal(programme) + if providerDataJSONErr != nil { + return nil, fmt.Errorf("error when marshalling providerData for use in guide_source_programme insert: %s", providerDataJSONErr) } date := time.Time(programme.Date) insertingProgramme := GuideSourceProgramme{ - GuideID: guideID, - Channel: programme.Channel, - StartTime: &programme.Start.Time, - EndTime: &programme.Stop.Time, - Date: &date, - Data: marshalled, + GuideID: guideID, + Channel: programme.Channel, + ProviderData: providerDataJSON, + StartTime: &programme.Start.Time, + EndTime: &programme.Stop.Time, + Date: &date, + Data: programmeJSON, } res, err := db.SQL.NamedExec(` - INSERT OR REPLACE INTO guide_source_programme (guide_id, channel, start, end, date, data) - VALUES (:guide_id, :channel, :start, :end, :date, :data)`, insertingProgramme) + INSERT OR REPLACE INTO guide_source_programme (guide_id, channel, provider_data, start, end, date, data) + VALUES (:guide_id, :channel, :provider_data, :start, :end, :date, :data)`, insertingProgramme) if err != nil { return nil, fmt.Errorf("error when inserting guide_source_programme row: %s", err) } From 531c39cbfca81f1e780a072b3e526dc3f67b1e66 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Mon, 27 Aug 2018 17:39:44 -0700 Subject: [PATCH 089/182] Get guide data updating going --- api/tuner.go | 32 -------------------------- commands/guide_updates.go | 48 +++++++++++++++++++++++++++++++++------ commands/video_updates.go | 14 +++++++----- main.go | 25 ++++++++++++++++---- migrations/00001_init.sql | 36 +++++++++++++++-------------- models/guide_source.go | 22 ++++++++++-------- models/lineup_channel.go | 42 ++++++++++++++++++++++++++++++++++ models/video_source.go | 24 +++++++++++--------- 8 files changed, 155 insertions(+), 88 deletions(-) diff --git a/api/tuner.go b/api/tuner.go index 1e9c45e..e38f7b6 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -31,41 +31,9 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { return } - guideSources, guideSourceErr := cc.API.GuideSource.GetGuideSourcesForLineup(lineup.ID) - if guideSourceErr != nil { - log.WithError(guideSourceErr).Errorln("error getting guide sources for lineup") - return - } - - guideSourceUpdateMap := make(map[int][]string) - hdhrItems := make([]models.HDHomeRunLineupItem, 0) for _, channel := range channels { hdhrItems = append(hdhrItems, *channel.HDHR) - - guideSourceUpdateMap[channel.GuideChannel.GuideSource.ID] = append(guideSourceUpdateMap[channel.GuideChannel.GuideSource.ID], channel.GuideChannel.XMLTVID) - } - - for _, guideSource := range guideSources { - if channelsToGet, ok := guideSourceUpdateMap[guideSource.ID]; ok { - log.Infof("Beginning import of guide data from provider %s, getting channels %s", guideSource.Name, strings.Join(channelsToGet, ", ")) - schedule, scheduleErr := cc.GuideSourceProviders[guideSource.ID].Schedule(channelsToGet) - if scheduleErr != nil { - log.WithError(scheduleErr).Errorf("error when updating schedule for provider %s", guideSource.Name) - return - } - - for _, programme := range schedule { - _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(guideSource.ID, programme, nil) - if programmeErr != nil { - log.WithError(programmeErr).Errorln("error while inserting programmes") - return - } - } - - log.Infof("Completed import of %d programs", len(schedule)) - - } } metrics.ExposedChannels.WithLabelValues(lineup.Name).Set(float64(len(channels))) diff --git a/commands/guide_updates.go b/commands/guide_updates.go index 5fb2f47..ea27724 100644 --- a/commands/guide_updates.go +++ b/commands/guide_updates.go @@ -1,10 +1,13 @@ package commands import ( + "fmt" "os" + "strings" "github.com/sirupsen/logrus" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/utils" ) var ( @@ -18,28 +21,59 @@ var ( } ) -// FireGuideUpdatesCommand Command to fire one off video source updates +// FireGuideUpdatesCommand Command to fire one off guide source updates func FireGuideUpdatesCommand() { cc, err := context.NewCContext() if err != nil { log.Fatalln("Couldn't create context", err) } - if err = fireGuideUpdates(cc); err != nil { + // FIXME: Don't hardcode this + if err = fireGuideUpdates(cc, 1); err != nil { log.Errorln("Could not complete guide updates " + err.Error()) } } -func fireGuideUpdates(cc *context.CContext) error { +func fireGuideUpdates(cc *context.CContext, providerID int) error { + + log.Infoln("Guide source update is beginning") + + guideChannels, guideChannelsErr := cc.API.LineupChannel.GetEnabledChannelsForGuideProvider(providerID) + if guideChannelsErr != nil { + return fmt.Errorf("error getting guide sources for lineup: %s", guideChannelsErr) + } + + channelsToGet := make([]string, 0) + + for _, channel := range guideChannels { + if !utils.Contains(channelsToGet, channel.GuideChannel.XMLTVID) { + channelsToGet = append(channelsToGet, channel.GuideChannel.XMLTVID) + } + } + + log.Infof("Beginning import of guide data from provider %d, getting channels %s", providerID, strings.Join(channelsToGet, ", ")) + schedule, scheduleErr := cc.GuideSourceProviders[providerID].Schedule(channelsToGet) + if scheduleErr != nil { + return fmt.Errorf("error when updating schedule for provider %s: %s", providerID, scheduleErr) + } + + for _, programme := range schedule { + _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(providerID, programme, nil) + if programmeErr != nil { + return fmt.Errorf("error while inserting programmes: %s", programmeErr) + } + } + + log.Infof("Completed import of %d programs", len(schedule)) return nil } // StartFireGuideUpdates Scheduler triggered function to update guide sources -func StartFireGuideUpdates(cc *context.CContext) { - err := fireVideoUpdates(cc) +func StartFireGuideUpdates(cc *context.CContext, providerID int) { + err := fireGuideUpdates(cc, providerID) if err != nil { - log.Errorln("Could not complete video updates " + err.Error()) + log.Errorln("Could not complete guide updates " + err.Error()) } - log.Infoln("Video source has been updated successfully") + log.Infoln("Guide source has been updated successfully") } diff --git a/commands/video_updates.go b/commands/video_updates.go index 8770457..f8034e3 100644 --- a/commands/video_updates.go +++ b/commands/video_updates.go @@ -1,6 +1,8 @@ package commands import ( + "fmt" + "github.com/tellytv/telly/context" ) @@ -8,24 +10,24 @@ import ( func FireVideoUpdatesCommand() { cc, err := context.NewCContext() if err != nil { - log.Fatalln("Couldn't create context", err) + panic(fmt.Errorf("couldn't create context: %s", err)) } if err = fireVideoUpdates(cc); err != nil { - log.Errorln("Could not complete video updates " + err.Error()) + panic(fmt.Errorf("could not complete video updates: %s", err)) } } -// func fireVideoUpdates(cc *context.CContext) error { + fmt.Println("VIDEO source update is beginning") return nil } // StartFireVideoUpdates Scheduler triggered function to update video sources -func StartFireVideoUpdates(cc *context.CContext) { +func StartFireVideoUpdates(cc *context.CContext, providerID int) { err := fireVideoUpdates(cc) if err != nil { - log.Errorln("Could not complete video updates " + err.Error()) + panic(fmt.Errorf("could not complete video updates: %s", err.Error())) } - log.Infoln("Video source has been updated successfully") + fmt.Println("Video source has been updated successfully") } diff --git a/main.go b/main.go index 363e823..5700554 100644 --- a/main.go +++ b/main.go @@ -102,19 +102,34 @@ func main() { log.WithError(err).Panicln("Couldn't create context") } - lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(false) + lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(true) if lineupsErr != nil { log.WithError(lineupsErr).Panicln("Error getting all enabled lineups") } + c := cron.New() + for _, lineup := range lineups { api.StartTuner(cc, &lineup) - } - c := cron.New() + // videoProviders := make(map[int]string) + guideProviders := make(map[int]string) + for _, channel := range lineup.Channels { + // videoProviders[channel.VideoTrack.VideoSource.ID] = channel.VideoTrack.VideoSource.UpdateFrequency + guideProviders[channel.GuideChannel.GuideSource.ID] = channel.GuideChannel.GuideSource.UpdateFrequency + } + + // for videoProviderID, updateFrequencey := range videoProviders { + // c.AddFunc(updateFrequencey, func() { commands.StartFireVideoUpdates(cc, videoProviderID) }) + // } + + for guideProviderID, updateFrequencey := range guideProviders { + c.AddFunc(updateFrequencey, func() { commands.StartFireGuideUpdates(cc, guideProviderID) }) + } + } - c.AddFunc("@daily", func() { commands.StartFireVideoUpdates(cc) }) - c.AddFunc("@daily", func() { commands.StartFireGuideUpdates(cc) }) + c.Start() + log.Infof("CRON ENTRIES %+v", c.Entries()) api.ServeAPI(cc) } diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql index 79fe1df..2ceea9e 100644 --- a/migrations/00001_init.sql +++ b/migrations/00001_init.sql @@ -2,15 +2,16 @@ -- SQL in this section is executed when the migration is applied. CREATE TABLE IF NOT EXISTS video_source ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT, - provider VARCHAR(64) NULL, - username VARCHAR(64) NULL, - password VARCHAR(64) NULL, - base_url TEXT, - m3u_url TEXT, - max_streams INTEGER, - imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + provider VARCHAR(64) NULL, + username VARCHAR(64) NULL, + password VARCHAR(64) NULL, + base_url TEXT, + m3u_url TEXT, + max_streams INTEGER, + update_frequency TEXT, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE IF NOT EXISTS video_source_track ( @@ -28,14 +29,15 @@ CREATE TABLE IF NOT EXISTS video_source_track ( ); CREATE TABLE IF NOT EXISTS guide_source ( - id INTEGER PRIMARY KEY AUTOINCREMENT, - name TEXT, - provider VARCHAR(64) NULL, - username VARCHAR(64) NULL, - password VARCHAR(64) NULL, - xmltv_url TEXT, - provider_data TEXT, - imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + id INTEGER PRIMARY KEY AUTOINCREMENT, + name TEXT, + provider VARCHAR(64) NULL, + username VARCHAR(64) NULL, + password VARCHAR(64) NULL, + xmltv_url TEXT, + provider_data TEXT, + update_frequency TEXT, + imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); CREATE TABLE IF NOT EXISTS guide_source_channel ( diff --git a/models/guide_source.go b/models/guide_source.go index ae7c984..cd1b4a3 100644 --- a/models/guide_source.go +++ b/models/guide_source.go @@ -32,14 +32,15 @@ func (db *GuideSourceDB) tableName() string { // GuideSource describes a source of EPG data. type GuideSource struct { - ID int `db:"id"` - Name string `db:"name"` - Provider string `db:"provider"` - Username string `db:"username"` - Password string `db:"password"` - URL string `db:"xmltv_url"` - ProviderData json.RawMessage `db:"provider_data"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + Name string `db:"name"` + Provider string `db:"provider"` + Username string `db:"username"` + Password string `db:"password"` + URL string `db:"xmltv_url"` + ProviderData json.RawMessage `db:"provider_data"` + UpdateFrequency string `db:"update_frequency"` + ImportedAt *time.Time `db:"imported_at"` Channels []GuideSourceChannel `db:"-"` } @@ -74,6 +75,7 @@ SELECT G.password, G.xmltv_url, G.provider_data, + G.update_frequency, G.imported_at FROM guide_source G` @@ -89,8 +91,8 @@ func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource, provid guideSourceStruct.ProviderData = providerDataJSON res, err := db.SQL.NamedExec(` - INSERT INTO guide_source (name, provider, username, password, xmltv_url, provider_data) - VALUES (:name, :provider, :username, :password, :xmltv_url, :provider_data);`, guideSourceStruct) + INSERT INTO guide_source (name, provider, username, password, xmltv_url, provider_data, update_frequency) + VALUES (:name, :provider, :username, :password, :xmltv_url, :provider_data, :update_frequency);`, guideSourceStruct) if err != nil { return &guideSource, err } diff --git a/models/lineup_channel.go b/models/lineup_channel.go index 1197a02..cd0137c 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -113,6 +113,8 @@ type LineupChannelAPI interface { UpdateLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) GetLineupChannelByID(lineupID int, channelNumber string) (*LineupChannel, error) GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) + GetEnabledChannelsForGuideProvider(providerID int) ([]LineupChannel, error) + GetEnabledChannelsForVideoProvider(providerID int) ([]LineupChannel, error) } const baseLineupChannelQuery string = ` @@ -205,3 +207,43 @@ func (db *LineupChannelDB) GetChannelsForLineup(lineupID int, expanded bool) ([] } return channels, nil } + +// GetEnabledChannelsForGuideProvider returns a slice of LineupChannels for the given guide provider ID. +func (db *LineupChannelDB) GetEnabledChannelsForGuideProvider(providerID int) ([]LineupChannel, error) { + channels := make([]LineupChannel, 0) + err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE C.guide_channel_id IN (SELECT id FROM guide_source_channel WHERE guide_id = $1)`, baseLineupChannelQuery), providerID) + if err != nil { + return nil, err + } + // Need to get the address and port number to properly fill + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(channels[0].LineupID, false) + if lineupErr != nil { + return nil, lineupErr + } + for idx, channel := range channels { + channel.lineup = lineup + channel.Fill(db.Collection) + channels[idx] = channel + } + return channels, err +} + +// GetEnabledChannelsForVideoProvider returns a slice of LineupChannels for the given video provider ID. +func (db *LineupChannelDB) GetEnabledChannelsForVideoProvider(providerID int) ([]LineupChannel, error) { + channels := make([]LineupChannel, 0) + err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE C.video_track_id IN (SELECT id FROM video_source_track WHERE video_source_id = $1)`, baseLineupChannelQuery), providerID) + if err != nil { + return nil, err + } + // Need to get the address and port number to properly fill + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(channels[0].LineupID, false) + if lineupErr != nil { + return nil, lineupErr + } + for idx, channel := range channels { + channel.lineup = lineup + channel.Fill(db.Collection) + channels[idx] = channel + } + return channels, err +} diff --git a/models/video_source.go b/models/video_source.go index df3b6ff..4854135 100644 --- a/models/video_source.go +++ b/models/video_source.go @@ -31,15 +31,16 @@ func (db *VideoSourceDB) tableName() string { // VideoSource is a source of video streams. type VideoSource struct { - ID int `db:"id"` - Name string `db:"name"` - Provider string `db:"provider"` - Username string `db:"username"` - Password string `db:"password"` - BaseURL string `db:"base_url"` - M3UURL string `db:"m3u_url"` - MaxStreams int `db:"max_streams"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + Name string `db:"name"` + Provider string `db:"provider"` + Username string `db:"username"` + Password string `db:"password"` + BaseURL string `db:"base_url"` + M3UURL string `db:"m3u_url"` + MaxStreams int `db:"max_streams"` + UpdateFrequency string `db:"update_frequency"` + ImportedAt *time.Time `db:"imported_at"` Tracks []VideoSourceTrack `db:"tracks"` } @@ -75,6 +76,7 @@ SELECT V.base_url, V.m3u_url, V.max_streams, + V.update_frequency, V.imported_at FROM video_source V` @@ -82,8 +84,8 @@ SELECT func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) { videoSource := VideoSource{} res, err := db.SQL.NamedExec(` - INSERT INTO video_source (name, provider, username, password, base_url, m3u_url, max_streams) - VALUES (:name, :provider, :username, :password, :base_url, :m3u_url, :max_streams);`, videoSourceStruct) + INSERT INTO video_source (name, provider, username, password, base_url, m3u_url, max_streams, update_frequency) + VALUES (:name, :provider, :username, :password, :base_url, :m3u_url, :max_streams, :update_frequency);`, videoSourceStruct) if err != nil { return &videoSource, err } From 7c41d44304ff3e1ff9aa80b54df350035a5ed812 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 28 Aug 2018 13:55:18 -0700 Subject: [PATCH 090/182] Initial support for Schedules Direct caching --- Gopkg.lock | 4 +- api/guide_source.go | 14 +- commands/guide_updates.go | 83 ++- internal/guideproviders/main.go | 13 +- internal/guideproviders/schedules_direct.go | 680 ++++++++++++-------- internal/guideproviders/xmltv.go | 20 +- internal/m3uplus/main.go | 2 +- main.go | 10 +- models/guide_source.go | 9 +- models/guide_source_channel.go | 9 +- models/guide_source_programme.go | 11 +- 11 files changed, 532 insertions(+), 323 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index c922667..da9e07a 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -307,11 +307,11 @@ [[projects]] branch = "master" - digest = "1:933270bbac9095788f6e3ad0e11331173170627176ffee27e722c3e7e0bb38be" + digest = "1:189ca3d42cf31e7ae31a31e17f4a860c8c9f1f164e28b242b3434658d2f6e41c" name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" - revision = "e76717848560ef3975a9d20b559b1b1639383e00" + revision = "34412a2eb0519d921a72e24a3e17e8a335dcdab9" [[projects]] branch = "master" diff --git a/api/guide_source.go b/api/guide_source.go index 6980452..7910f80 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -1,6 +1,7 @@ package api import ( + "fmt" "net/http" "github.com/gin-gonic/gin" @@ -29,6 +30,17 @@ func addGuide(cc *context.CContext, c *gin.Context) { log.Infoln("Detected passed config is for provider", provider.Name()) + lineupMetadata, reloadErr := provider.Refresh(nil) + if reloadErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while initializing guide data provider: %s", reloadErr)) + return + } + + if updateErr := cc.API.GuideSource.UpdateGuideSource(newGuide.ID, lineupMetadata); updateErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while updating guide source with provider state: %s", updateErr)) + return + } + channels, channelsErr := provider.Channels() if channelsErr != nil { log.WithError(channelsErr).Errorln("unable to get channels from provider") @@ -39,7 +51,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { for _, channel := range channels { newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(newGuide.ID, channel, nil) if newChannelErr != nil { - log.WithError(newChannelErr).Errorln("Error creating new guide source channel!") + log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) c.AbortWithError(http.StatusInternalServerError, newChannelErr) return } diff --git a/commands/guide_updates.go b/commands/guide_updates.go index ea27724..3f2ead4 100644 --- a/commands/guide_updates.go +++ b/commands/guide_updates.go @@ -1,13 +1,15 @@ package commands import ( + "encoding/json" "fmt" "os" "strings" "github.com/sirupsen/logrus" "github.com/tellytv/telly/context" - "github.com/tellytv/telly/utils" + "github.com/tellytv/telly/internal/guideproviders" + "github.com/tellytv/telly/models" ) var ( @@ -27,37 +29,88 @@ func FireGuideUpdatesCommand() { if err != nil { log.Fatalln("Couldn't create context", err) } - // FIXME: Don't hardcode this - if err = fireGuideUpdates(cc, 1); err != nil { + + provider, providerErr := cc.API.GuideSource.GetGuideSourceByID(1) + if providerErr != nil { + log.Fatalln("couldnt find guide source", providerErr) + } + + if err = fireGuideUpdates(cc, provider); err != nil { log.Errorln("Could not complete guide updates " + err.Error()) } } -func fireGuideUpdates(cc *context.CContext, providerID int) error { +func fireGuideUpdates(cc *context.CContext, provider *models.GuideSource) error { log.Infoln("Guide source update is beginning") - guideChannels, guideChannelsErr := cc.API.LineupChannel.GetEnabledChannelsForGuideProvider(providerID) + lineupMetadata, reloadErr := cc.GuideSourceProviders[provider.ID].Refresh(provider.ProviderData) + if reloadErr != nil { + return fmt.Errorf("error when refreshing for provider %s (%s): %s", provider.Name, provider.Provider, reloadErr) + } + + if updateErr := cc.API.GuideSource.UpdateGuideSource(provider.ID, lineupMetadata); updateErr != nil { + return fmt.Errorf("error when updating guide source provider metadata: %s", updateErr) + } + + // TODO: Inspect the input metadata and output metadata and update channels as needed. + + guideChannels, guideChannelsErr := cc.API.LineupChannel.GetEnabledChannelsForGuideProvider(provider.ID) if guideChannelsErr != nil { return fmt.Errorf("error getting guide sources for lineup: %s", guideChannelsErr) } - channelsToGet := make([]string, 0) + channelsToGet := make(map[string]guideproviders.Channel) for _, channel := range guideChannels { - if !utils.Contains(channelsToGet, channel.GuideChannel.XMLTVID) { - channelsToGet = append(channelsToGet, channel.GuideChannel.XMLTVID) + var pChannel guideproviders.Channel + if marshalErr := json.Unmarshal(channel.GuideChannel.Data, &pChannel); marshalErr != nil { + return fmt.Errorf("error when marshalling channel.data to guideproviders.channel: %s", marshalErr) } + pChannel.ProviderData = channel.GuideChannel.ProviderData + channelsToGet[channel.GuideChannel.XMLTVID] = pChannel + } + + channelIDs := make([]string, 0) + existingChannels := make([]guideproviders.Channel, 0) + for channelID, channel := range channelsToGet { + channelIDs = append(channelIDs, channelID) + existingChannels = append(existingChannels, channel) } - log.Infof("Beginning import of guide data from provider %d, getting channels %s", providerID, strings.Join(channelsToGet, ", ")) - schedule, scheduleErr := cc.GuideSourceProviders[providerID].Schedule(channelsToGet) + // Get all programmes in DB to pass into the Schedule function. + programmes, programmesErr := cc.API.GuideSourceProgramme.GetProgrammesForActiveChannels() + if programmesErr != nil { + return fmt.Errorf("error getting all programmes in database: %s", programmesErr) + } + + containers := make([]guideproviders.ProgrammeContainer, 0) + for _, programme := range programmes { + containers = append(containers, guideproviders.ProgrammeContainer{ + Programme: *programme.XMLTV, + ProviderData: programme.ProviderData, + }) + } + + log.Infof("Beginning import of guide data from provider %d, getting %d channels: %s", provider.ID, len(channelsToGet), strings.Join(channelIDs, ", ")) + channelProviderData, schedule, scheduleErr := cc.GuideSourceProviders[provider.ID].Schedule(existingChannels, containers) if scheduleErr != nil { - return fmt.Errorf("error when updating schedule for provider %s: %s", providerID, scheduleErr) + return fmt.Errorf("error when updating schedule for provider %s: %s", provider.ID, scheduleErr) + } + + for channelID, providerData := range channelProviderData { + marshalledPD, marshalErr := json.Marshal(providerData) + if marshalErr != nil { + return fmt.Errorf("error when marshalling schedules direct channel data to json: %s", marshalErr) + } + log.Infof("Updating Channel ID: %s to %s", channelID, string(marshalledPD)) + if updateErr := cc.API.GuideSourceChannel.UpdateGuideSourceChannel(channelID, marshalledPD); updateErr != nil { + return fmt.Errorf("error while updating provider specific data to guide source channel: %s", updateErr) + } } for _, programme := range schedule { - _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(providerID, programme, nil) + _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(provider.ID, programme.Programme, programme.ProviderData) if programmeErr != nil { return fmt.Errorf("error while inserting programmes: %s", programmeErr) } @@ -69,10 +122,10 @@ func fireGuideUpdates(cc *context.CContext, providerID int) error { } // StartFireGuideUpdates Scheduler triggered function to update guide sources -func StartFireGuideUpdates(cc *context.CContext, providerID int) { - err := fireGuideUpdates(cc, providerID) +func StartFireGuideUpdates(cc *context.CContext, provider *models.GuideSource) { + err := fireGuideUpdates(cc, provider) if err != nil { - log.Errorln("Could not complete guide updates " + err.Error()) + log.Errorf("could not complete guide updates: %s", err) } log.Infoln("Guide source has been updated successfully") diff --git a/internal/guideproviders/main.go b/internal/guideproviders/main.go index 9cc15e6..a2c1460 100644 --- a/internal/guideproviders/main.go +++ b/internal/guideproviders/main.go @@ -44,6 +44,8 @@ type Channel struct { CallSign string URLs []string Lineup string + + ProviderData interface{} } // XMLTV returns the xmltv.Channel representation of the Channel. @@ -88,12 +90,19 @@ type Logo struct { Width int `json:"width"` } +// ProgrammeContainer contains information about a single provider in the XMLTV format +// as well as provider specific data. +type ProgrammeContainer struct { + Programme xmltv.Programme + ProviderData interface{} +} + // GuideProvider describes a IPTV provider configuration. type GuideProvider interface { Name() string Channels() ([]Channel, error) - Schedule(channelIDs []string) ([]xmltv.Programme, error) + Schedule(inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) - Refresh() error + Refresh(lineupStateJSON []byte) ([]byte, error) Configuration() Configuration } diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index e364670..0212dbc 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -1,7 +1,9 @@ package guideproviders import ( + "encoding/json" "fmt" + "reflect" "strconv" "strings" "time" @@ -21,13 +23,7 @@ type SchedulesDirect struct { } func newSchedulesDirect(config *Configuration) (GuideProvider, error) { - provider := &SchedulesDirect{BaseConfig: *config} - - if loadErr := provider.Refresh(); loadErr != nil { - return nil, fmt.Errorf("error when refreshing provider data: %s", loadErr) - } - - return provider, nil + return &SchedulesDirect{BaseConfig: *config}, nil } // Name returns the name of the GuideProvider. @@ -41,24 +37,111 @@ func (s *SchedulesDirect) Channels() ([]Channel, error) { } // Schedule returns a slice of xmltv.Programme for the given channelIDs. -func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, error) { - // First, convert the string slice of channelIDs into a slice of schedule requests. +func (s *SchedulesDirect) Schedule(inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { + // First, convert the slice of channelIDs into a slice of schedule requests. reqs := make([]schedulesdirect.StationScheduleRequest, 0) - for _, channelID := range channelIDs { - splitID := strings.Split(channelID, ".")[1] + channelsCache := make(map[string]map[string]schedulesdirect.LastModifiedEntry) + requestingDates := getDaysBetweenTimes(time.Now(), time.Now().AddDate(0, 0, 7)) + channelShortToLongIDMap := make(map[string]string) + for _, inputChannel := range inputChannels { + splitID := strings.Split(inputChannel.ID, ".")[1] + + channelShortToLongIDMap[splitID] = inputChannel.ID + + if len(inputChannel.ProviderData.(json.RawMessage)) > 0 { + channelCache := make(map[string]schedulesdirect.LastModifiedEntry) + if unmarshalErr := json.Unmarshal(inputChannel.ProviderData.(json.RawMessage), &channelCache); unmarshalErr != nil { + return nil, nil, unmarshalErr + } + + if len(channelCache) > 0 { + fmt.Printf("Channel %s exists in cache already with %d days of schedule available\n", inputChannel.ID, len(channelCache)) + channelsCache[splitID] = channelCache + } + } + reqs = append(reqs, schedulesdirect.StationScheduleRequest{ StationID: splitID, - Dates: []string{time.Now().Format("2006-01-02"), time.Now().AddDate(0, 0, 7).Format("2006-01-02")}, + Dates: requestingDates, }) } - // Next, get the results - schedules, schedulesErr := s.client.GetSchedules(reqs) + // Next, we get all modified parts of the schedule for any channels. + lastModifieds, lastModifiedsErr := s.client.GetLastModified(reqs) + if lastModifiedsErr != nil { + return nil, nil, fmt.Errorf("error getting lastModifieds from lastModifieds direct: %s", lastModifiedsErr) + } + + channelsNeedingUpdate := make(map[string][]string) + + for stationID, dates := range lastModifieds { + longStationID := channelShortToLongIDMap[stationID] + if channelsNeedingUpdate[stationID] == nil { + channelsNeedingUpdate[stationID] = make([]string, 0) + } + for date, lastMod := range dates { + needsData := false + if cachedDate, ok := channelsCache[stationID][date]; ok { + fmt.Printf("For date %s: checking cached MD5 %s against server MD5 %s for %s\n", date, cachedDate.MD5, lastMod.MD5, longStationID) + if cachedDate.MD5 != lastMod.MD5 { + fmt.Printf("Station %s needs updated data for %s\n", longStationID, date) + needsData = true + channelsNeedingUpdate[stationID] = append(channelsNeedingUpdate[stationID], date) + } + } else { + fmt.Printf("Station %s needs data for %s\n", longStationID, date) + needsData = true + channelsNeedingUpdate[stationID] = append(channelsNeedingUpdate[stationID], date) + } + if needsData { + if channelsCache[stationID] == nil { + channelsCache[stationID] = make(map[string]schedulesdirect.LastModifiedEntry) + } + channelsCache[stationID][date] = lastMod + } + } + if _, ok := channelsCache[stationID]; !ok { + fmt.Printf("Station %s needs initial data\n", longStationID) + channelsNeedingUpdate[stationID] = requestingDates + continue + } + } + + fullScheduleReqs := make([]schedulesdirect.StationScheduleRequest, 0) + // Next, using the channelsNeedingUpdate, build new schedule requests for station(s) missing data for date(s). + // Let's also add all these values to channelsCache to use that for the return. + for stationID, dates := range channelsNeedingUpdate { + if len(dates) > 0 { + fmt.Printf("Requesting dates %s for station %s\n", strings.Join(dates, ", "), stationID) + fullScheduleReqs = append(fullScheduleReqs, schedulesdirect.StationScheduleRequest{ + StationID: stationID, + Dates: dates, + }) + } + } + + outputChannelsMap := make(map[string]interface{}, 0) + for shortChannelID, longChannelID := range channelShortToLongIDMap { + outputChannelsMap[longChannelID] = channelsCache[shortChannelID] + } + + if reflect.DeepEqual(outputChannelsMap, channelsCache) { + outputChannelsMap = nil + } + + // Great, we don't need to get any new schedule data, let's terminate early. + if len(fullScheduleReqs) == 0 { + fmt.Println("No updates required, exiting Schedule()") + return outputChannelsMap, nil, nil + } + + // So we do have some requests to make, let's do that now. + schedules, schedulesErr := s.client.GetSchedules(fullScheduleReqs) if schedulesErr != nil { - return nil, fmt.Errorf("error getting schedules from schedules direct: %s", schedulesErr) + return nil, nil, fmt.Errorf("error getting schedules from schedules direct: %s", schedulesErr) } - // Then, we need to bundle up all the program IDs and request detailed information about them. + // Next, we need to bundle up all the program IDs and request detailed information about them. neededProgramIDs := make(map[string]struct{}, 0) for _, schedule := range schedules { @@ -75,7 +158,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro for _, chunk := range utils.ChunkStringSlice(utils.GetStringMapKeys(neededProgramIDs), 5000) { moreInfo, moreInfoErr := s.client.GetProgramInfo(chunk) if moreInfoErr != nil { - return nil, fmt.Errorf("error when getting more program details from schedules direct: %s", moreInfoErr) + return nil, nil, fmt.Errorf("error when getting more program details from schedules direct: %s", moreInfoErr) } for _, program := range moreInfo { @@ -92,7 +175,7 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro for _, chunk := range utils.ChunkStringSlice(utils.GetStringMapKeys(programsWithArtwork), 500) { artworkResp, artworkErr := s.client.GetArtworkForProgramIDs(chunk) if artworkErr != nil { - return nil, fmt.Errorf("error when getting artwork from schedules direct: %s", artworkErr) + return nil, nil, fmt.Errorf("error when getting artwork from schedules direct: %s", artworkErr) } for _, artworks := range artworkResp { @@ -101,286 +184,70 @@ func (s *SchedulesDirect) Schedule(channelIDs []string) ([]xmltv.Programme, erro } // We finally have all the data, time to convert to the XMLTV format. - programmes := make([]xmltv.Programme, 0) + programmes := make([]ProgrammeContainer, 0) // Iterate over every result, converting to XMLTV format. for _, schedule := range schedules { station := s.stations[schedule.StationID] - for _, airing := range schedule.Programs { - programInfo := extendedProgramInfo[airing.ProgramID] - endTime := airing.AirDateTime.Add(time.Duration(airing.Duration) * time.Second) - length := xmltv.Length{Units: "seconds", Value: strconv.Itoa(airing.Duration)} - - // First we fill in all the "simple" fields that don't require any extra processing. - xmlProgramme := xmltv.Programme{ - Channel: fmt.Sprintf("I%s.%s.schedulesdirect.org", station.ChannelMap.Channel, station.Station.StationID), - ID: airing.ProgramID, - Languages: []xmltv.CommonElement{xmltv.CommonElement{ - Value: station.Station.BroadcastLanguage[0], - Lang: station.Station.BroadcastLanguage[0], - }}, - Length: &length, - Start: &xmltv.Time{Time: airing.AirDateTime}, - Stop: &xmltv.Time{Time: endTime}, - } - - // Now for the fields that have to be parsed. - xmlProgramme.Titles = make([]xmltv.CommonElement, 0) - for _, sdTitle := range programInfo.Titles { - xmlProgramme.Titles = append(xmlProgramme.Titles, xmltv.CommonElement{ - Value: sdTitle.Title120, - }) - } - - if programInfo.EpisodeTitle150 != "" { - xmlProgramme.SecondaryTitles = []xmltv.CommonElement{xmltv.CommonElement{ - Value: programInfo.EpisodeTitle150, - }} - } - - xmlProgramme.Descriptions = make([]xmltv.CommonElement, 0) - for _, sdDescription := range programInfo.GetOrderedDescriptions() { - xmlProgramme.Descriptions = append(xmlProgramme.Descriptions, xmltv.CommonElement{ - Value: sdDescription.Description, - Lang: sdDescription.Language, - }) - } - - for _, sdCast := range append(programInfo.Cast, programInfo.Crew...) { - if xmlProgramme.Credits == nil { - xmlProgramme.Credits = &xmltv.Credits{} - } - lowerRole := strings.ToLower(sdCast.Role) - if strings.Contains(lowerRole, "director") { - xmlProgramme.Credits.Directors = append(xmlProgramme.Credits.Directors, sdCast.Name) - } else if strings.Contains(lowerRole, "actor") || strings.Contains(lowerRole, "voice") { - role := "" - if sdCast.Role != "Actor" { - role = sdCast.Role - } - xmlProgramme.Credits.Actors = append(xmlProgramme.Credits.Actors, xmltv.Actor{ - Role: role, - Value: sdCast.Name, - }) - } else if strings.Contains(lowerRole, "writer") { - xmlProgramme.Credits.Writers = append(xmlProgramme.Credits.Writers, sdCast.Name) - } else if strings.Contains(lowerRole, "producer") { - xmlProgramme.Credits.Producers = append(xmlProgramme.Credits.Producers, sdCast.Name) - } else if strings.Contains(lowerRole, "host") || strings.Contains(lowerRole, "anchor") { - xmlProgramme.Credits.Presenters = append(xmlProgramme.Credits.Presenters, sdCast.Name) - } else if strings.Contains(lowerRole, "guest") || strings.Contains(lowerRole, "contestant") { - xmlProgramme.Credits.Guests = append(xmlProgramme.Credits.Guests, sdCast.Name) - } - } - - if programInfo.Movie.Year != "" { - yearInt, yearIntErr := strconv.Atoi(programInfo.Movie.Year) - if yearIntErr == nil { // Date isn't that important of a field, if we hit an error while parsing just don't add date. - xmlProgramme.Date = xmltv.Date(time.Date(yearInt, 1, 1, 1, 1, 1, 1, time.UTC)) - } - } - - xmlProgramme.Categories = make([]xmltv.CommonElement, 0) - seenCategories := make(map[string]struct{}) - for _, sdCategory := range programInfo.Genres { - if _, ok := seenCategories[sdCategory]; !ok { - xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ - Value: sdCategory, - }) - seenCategories[sdCategory] = struct{}{} - } - } - - entityTypeCat := programInfo.EntityType - - if programInfo.EntityType == "episode" { - entityTypeCat = "series" - } - - if _, ok := seenCategories[entityTypeCat]; !ok { - xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ - Value: entityTypeCat, - }) - } - - seenKeywords := make(map[string]struct{}) - for _, keywords := range programInfo.Keywords { - for _, keyword := range keywords { - if _, ok := seenKeywords[keyword]; !ok { - xmlProgramme.Keywords = append(xmlProgramme.Keywords, xmltv.CommonElement{ - Value: utils.KebabCase(keyword), - }) - seenKeywords[keyword] = struct{}{} - } - } - } - - if programInfo.OfficialURL != "" { - xmlProgramme.URLs = []string{programInfo.OfficialURL} - } - - if artworks, ok := allArtwork[programInfo.ProgramID[:10]]; ok { - for _, artworkItem := range artworks { - if strings.HasPrefix(artworkItem.URI, "assets/") { - artworkItem.URI = fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", artworkItem.URI) - } - xmlProgramme.Icons = append(xmlProgramme.Icons, xmltv.Icon{ - Source: artworkItem.URI, - Width: artworkItem.Width, - Height: artworkItem.Height, - }) - } - } - - xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ - System: "dd_progid", - Value: programInfo.ProgramID, - }) - - xmltvns := getXMLTVNumber(programInfo.Metadata, airing.ProgramPart) - if xmltvns != "" { - xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmltvns}) - } - - sxxexx := "" - - for _, metadata := range programInfo.Metadata { - for _, mdProvider := range metadata { - if mdProvider.Season > 0 && mdProvider.Episode > 0 { - sxxexx = fmt.Sprintf("S%sE%s", utils.PadNumberWithZeros(mdProvider.Season, 2), utils.PadNumberWithZeros(mdProvider.Episode, 2)) - } - } - } - - if sxxexx != "" { - xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "SxxExx", Value: sxxexx}) - } - - for _, videoProperty := range airing.VideoProperties { - if xmlProgramme.Video == nil { - xmlProgramme.Video = &xmltv.Video{} - } - if station.Station.IsRadioStation { - continue - } - xmlProgramme.Video.Present = "yes" - if strings.ToLower(videoProperty) == "hdtv" { - xmlProgramme.Video.Quality = "HDTV" - xmlProgramme.Video.Aspect = "16:9" - } else if strings.ToLower(videoProperty) == "uhdtv" { - xmlProgramme.Video.Quality = "UHD" - } else if strings.ToLower(videoProperty) == "sdtv" { - xmlProgramme.Video.Aspect = "4:3" - } - } - - for _, audioProperty := range airing.AudioProperties { - switch strings.ToLower(audioProperty) { - case "dd": - xmlProgramme.Audio = &xmltv.Audio{Stereo: "dolby digital"} - case "dd 5.1", "surround", "atmos": - xmlProgramme.Audio = &xmltv.Audio{Stereo: "surround"} - case "dolby": - xmlProgramme.Audio = &xmltv.Audio{Stereo: "dolby"} - case "stereo": - xmlProgramme.Audio = &xmltv.Audio{Stereo: "stereo"} - case "mono": - xmlProgramme.Audio = &xmltv.Audio{Stereo: "mono"} - case "cc", "subtitled": - xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "teletext"}) - } - } - - if airing.Signed { - xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "deaf-signed"}) - } - - if !time.Time(programInfo.OriginalAirDate).IsZero() { - if !airing.New { - xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ - Start: xmltv.Time{Time: time.Time(programInfo.OriginalAirDate)}, - } - } - timeToUse := time.Time(programInfo.OriginalAirDate) - if airing.New { - timeToUse = airing.AirDateTime - } - xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ - System: "original-air-date", - Value: timeToUse.Format("2006-01-02 15:04:05"), - }) - } - - if airing.Repeat && xmlProgramme.PreviouslyShown != nil { - xmlProgramme.PreviouslyShown = nil - } - - seenRatings := make(map[string]string) - for _, rating := range append(programInfo.ContentRating, airing.Ratings...) { - if _, ok := seenRatings[rating.Body]; !ok { - xmlProgramme.Ratings = append(xmlProgramme.Ratings, xmltv.Rating{ - Value: rating.Code, - System: rating.Body, - }) - seenRatings[rating.Body] = rating.Code - } - } - - for _, starRating := range programInfo.Movie.QualityRating { - xmlProgramme.StarRatings = append(xmlProgramme.StarRatings, xmltv.Rating{ - Value: fmt.Sprintf("%s/%s", starRating.Rating, starRating.MaxRating), - System: starRating.RatingsBody, - }) - } - - if airing.IsPremiereOrFinale != "" { - xmlProgramme.Premiere = &xmltv.CommonElement{ - Lang: "en", - Value: string(airing.IsPremiereOrFinale), - } - } - - if airing.Premiere { - xmlProgramme.Premiere = &xmltv.CommonElement{} + programme, programmeErr := s.processProgrammeToXMLTV(airing, extendedProgramInfo[airing.ProgramID], allArtwork[airing.ProgramID[:10]], station) + if programmeErr != nil { + return nil, nil, fmt.Errorf("error while processing schedules direct result to xmltv format: %s", programmeErr) } - - if airing.New { - elm := xmltv.ElementPresent(true) - xmlProgramme.New = &elm - } - - // Done processing! - programmes = append(programmes, xmlProgramme) - + programmes = append(programmes, *programme) } } - return programmes, nil + return outputChannelsMap, programmes, nil } // Refresh causes the provider to request the latest information. -func (s *SchedulesDirect) Refresh() error { +func (s *SchedulesDirect) Refresh(lastStatusJSON []byte) ([]byte, error) { if s.client == nil { sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) if sdClientErr != nil { - return fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + return nil, fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) } s.client = sdClient } + lineupsMetadataMap := make(map[string]schedulesdirect.Lineup) + var lastStatus schedulesdirect.StatusResponse + if len(lastStatusJSON) > 0 { + if unmarshalErr := json.Unmarshal(lastStatusJSON, &lastStatus); unmarshalErr != nil { + return nil, unmarshalErr + } + + for _, lineup := range lastStatus.Lineups { + lineupsMetadataMap[lineup.Lineup] = lineup + } + } + // First, get the lineups added to the users account. // SD API docs say to check system status before proceeding. // NewClient above does that automatically for us. status, statusErr := s.client.GetStatus() if statusErr != nil { - return fmt.Errorf("error getting schedules direct status: %s", statusErr) + return nil, fmt.Errorf("error getting schedules direct status: %s", statusErr) + } + + marshalledLineups, marshalledLineupsErr := json.Marshal(status) + if marshalledLineupsErr != nil { + return nil, fmt.Errorf("error when marshalling schedules direct lineups to json: %s", marshalledLineupsErr) } + // If there's anything in this slice we know that channels in the SD lineup are changing. allLineups := make([]string, 0) for _, lineup := range status.Lineups { + // if existingLineup, ok := lineupsMetadataMap[lineup.Lineup]; ok { + // // If lineup modified in database is not equal to lineup modified API provided + // // append lineup ID to allLineups + // if !existingLineup.Modified.Equal(lineup.Modified) { + // allLineups = append(allLineups, lineup.Lineup) + // } + // } allLineups = append(allLineups, lineup.Lineup) } @@ -402,13 +269,13 @@ func (s *SchedulesDirect) Refresh() error { // Sanity check if len(status.Lineups) == status.Account.MaxLineups && len(neededLineups) > 0 { - return fmt.Errorf("attempting to add more than %d lineups to a schedules direct account will fail, exiting prematurely", status.Account.MaxLineups) + return marshalledLineups, fmt.Errorf("attempting to add more than %d lineups to a schedules direct account will fail, exiting prematurely", status.Account.MaxLineups) } // Add needed lineups for _, neededLineupName := range neededLineups { if _, err := s.client.AddLineup(neededLineupName); err != nil { - return fmt.Errorf("error when adding lineup %s to schedules direct account: %s", neededLineupName, err) + return marshalledLineups, fmt.Errorf("error when adding lineup %s to schedules direct account: %s", neededLineupName, err) } allLineups = append(allLineups, neededLineupName) } @@ -417,7 +284,7 @@ func (s *SchedulesDirect) Refresh() error { for _, lineupName := range allLineups { channels, channelsErr := s.client.GetChannels(lineupName, true) if channelsErr != nil { - return fmt.Errorf("error getting channels from schedules direct for lineup %s: %s", lineupName, channelsErr) + return marshalledLineups, fmt.Errorf("error getting channels from schedules direct for lineup %s: %s", lineupName, channelsErr) } stationsMap := make(map[string]sdStationContainer) @@ -465,7 +332,7 @@ func (s *SchedulesDirect) Refresh() error { // We're done! - return nil + return marshalledLineups, nil } // Configuration returns the base configuration backing the provider. @@ -532,3 +399,272 @@ func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo s return "" } + +type sdProgrammeData struct { + Airing schedulesdirect.Program + ProgramInfo schedulesdirect.ProgramInfo + AllArtwork []schedulesdirect.ProgramArtwork + Station sdStationContainer +} + +func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program, programInfo schedulesdirect.ProgramInfo, allArtwork []schedulesdirect.ProgramArtwork, station sdStationContainer) (*ProgrammeContainer, error) { + stationID := fmt.Sprintf("I%s.%s.schedulesdirect.org", station.ChannelMap.Channel, station.Station.StationID) + endTime := airing.AirDateTime.Add(time.Duration(airing.Duration) * time.Second) + length := xmltv.Length{Units: "seconds", Value: strconv.Itoa(airing.Duration)} + + // First we fill in all the "simple" fields that don't require any extra processing. + xmlProgramme := xmltv.Programme{ + Channel: stationID, + ID: airing.ProgramID, + Length: &length, + Start: &xmltv.Time{Time: airing.AirDateTime}, + Stop: &xmltv.Time{Time: endTime}, + } + + // Now for the fields that have to be parsed. + for _, broadcastLang := range station.Station.BroadcastLanguage { + xmlProgramme.Languages = []xmltv.CommonElement{xmltv.CommonElement{ + Value: broadcastLang, + Lang: broadcastLang, + }} + } + + xmlProgramme.Titles = make([]xmltv.CommonElement, 0) + for _, sdTitle := range programInfo.Titles { + xmlProgramme.Titles = append(xmlProgramme.Titles, xmltv.CommonElement{ + Value: sdTitle.Title120, + }) + } + + if programInfo.EpisodeTitle150 != "" { + xmlProgramme.SecondaryTitles = []xmltv.CommonElement{xmltv.CommonElement{ + Value: programInfo.EpisodeTitle150, + }} + } + + xmlProgramme.Descriptions = make([]xmltv.CommonElement, 0) + for _, sdDescription := range programInfo.GetOrderedDescriptions() { + xmlProgramme.Descriptions = append(xmlProgramme.Descriptions, xmltv.CommonElement{ + Value: sdDescription.Description, + Lang: sdDescription.Language, + }) + } + + for _, sdCast := range append(programInfo.Cast, programInfo.Crew...) { + if xmlProgramme.Credits == nil { + xmlProgramme.Credits = &xmltv.Credits{} + } + lowerRole := strings.ToLower(sdCast.Role) + if strings.Contains(lowerRole, "director") { + xmlProgramme.Credits.Directors = append(xmlProgramme.Credits.Directors, sdCast.Name) + } else if strings.Contains(lowerRole, "actor") || strings.Contains(lowerRole, "voice") { + role := "" + if sdCast.Role != "Actor" { + role = sdCast.Role + } + xmlProgramme.Credits.Actors = append(xmlProgramme.Credits.Actors, xmltv.Actor{ + Role: role, + Value: sdCast.Name, + }) + } else if strings.Contains(lowerRole, "writer") { + xmlProgramme.Credits.Writers = append(xmlProgramme.Credits.Writers, sdCast.Name) + } else if strings.Contains(lowerRole, "producer") { + xmlProgramme.Credits.Producers = append(xmlProgramme.Credits.Producers, sdCast.Name) + } else if strings.Contains(lowerRole, "host") || strings.Contains(lowerRole, "anchor") { + xmlProgramme.Credits.Presenters = append(xmlProgramme.Credits.Presenters, sdCast.Name) + } else if strings.Contains(lowerRole, "guest") || strings.Contains(lowerRole, "contestant") { + xmlProgramme.Credits.Guests = append(xmlProgramme.Credits.Guests, sdCast.Name) + } + } + + if !programInfo.Movie.Year.Time.IsZero() { + xmlProgramme.Date = xmltv.Date(programInfo.Movie.Year.Time) + } + + xmlProgramme.Categories = make([]xmltv.CommonElement, 0) + seenCategories := make(map[string]struct{}) + for _, sdCategory := range programInfo.Genres { + if _, ok := seenCategories[sdCategory]; !ok { + xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ + Value: sdCategory, + }) + seenCategories[sdCategory] = struct{}{} + } + } + + entityTypeCat := programInfo.EntityType + + if programInfo.EntityType == "episode" { + entityTypeCat = "series" + } + + if _, ok := seenCategories[entityTypeCat]; !ok { + xmlProgramme.Categories = append(xmlProgramme.Categories, xmltv.CommonElement{ + Value: entityTypeCat, + }) + } + + seenKeywords := make(map[string]struct{}) + for _, keywords := range programInfo.Keywords { + for _, keyword := range keywords { + if _, ok := seenKeywords[keyword]; !ok { + xmlProgramme.Keywords = append(xmlProgramme.Keywords, xmltv.CommonElement{ + Value: utils.KebabCase(keyword), + }) + seenKeywords[keyword] = struct{}{} + } + } + } + + if programInfo.OfficialURL != "" { + xmlProgramme.URLs = []string{programInfo.OfficialURL} + } + + for _, artworkItem := range allArtwork { + if strings.HasPrefix(artworkItem.URI, "assets/") { + artworkItem.URI = fmt.Sprint(schedulesdirect.DefaultBaseURL, schedulesdirect.APIVersion, "/image/", artworkItem.URI) + } + xmlProgramme.Icons = append(xmlProgramme.Icons, xmltv.Icon{ + Source: artworkItem.URI, + Width: artworkItem.Width, + Height: artworkItem.Height, + }) + } + + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ + System: "dd_progid", + Value: programInfo.ProgramID, + }) + + xmltvns := getXMLTVNumber(programInfo.Metadata, airing.ProgramPart) + if xmltvns != "" { + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmltvns}) + } + + sxxexx := "" + + for _, metadata := range programInfo.Metadata { + for _, mdProvider := range metadata { + if mdProvider.Season > 0 && mdProvider.Episode > 0 { + sxxexx = fmt.Sprintf("S%sE%s", utils.PadNumberWithZeros(mdProvider.Season, 2), utils.PadNumberWithZeros(mdProvider.Episode, 2)) + } + } + } + + if sxxexx != "" { + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "SxxExx", Value: sxxexx}) + } + + for _, videoProperty := range airing.VideoProperties { + if xmlProgramme.Video == nil { + xmlProgramme.Video = &xmltv.Video{} + } + if station.Station.IsRadioStation { + continue + } + xmlProgramme.Video.Present = "yes" + if strings.ToLower(videoProperty) == "hdtv" { + xmlProgramme.Video.Quality = "HDTV" + xmlProgramme.Video.Aspect = "16:9" + } else if strings.ToLower(videoProperty) == "uhdtv" { + xmlProgramme.Video.Quality = "UHD" + } else if strings.ToLower(videoProperty) == "sdtv" { + xmlProgramme.Video.Aspect = "4:3" + } + } + + for _, audioProperty := range airing.AudioProperties { + switch strings.ToLower(audioProperty) { + case "dd": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "dolby digital"} + case "dd 5.1", "surround", "atmos": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "surround"} + case "dolby": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "dolby"} + case "stereo": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "stereo"} + case "mono": + xmlProgramme.Audio = &xmltv.Audio{Stereo: "mono"} + case "cc", "subtitled": + xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "teletext"}) + } + } + + if airing.Signed { + xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "deaf-signed"}) + } + + if !programInfo.OriginalAirDate.Time.IsZero() { + if !airing.New { + xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ + Start: xmltv.Time{Time: programInfo.OriginalAirDate.Time}, + } + } + timeToUse := programInfo.OriginalAirDate.Time + if airing.New { + timeToUse = airing.AirDateTime + } + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ + System: "original-air-date", + Value: timeToUse.Format("2006-01-02 15:04:05"), + }) + } + + if airing.Repeat && xmlProgramme.PreviouslyShown != nil { + xmlProgramme.PreviouslyShown = nil + } + + seenRatings := make(map[string]string) + for _, rating := range append(programInfo.ContentRating, airing.Ratings...) { + if _, ok := seenRatings[rating.Body]; !ok { + xmlProgramme.Ratings = append(xmlProgramme.Ratings, xmltv.Rating{ + Value: rating.Code, + System: rating.Body, + }) + seenRatings[rating.Body] = rating.Code + } + } + + for _, starRating := range programInfo.Movie.QualityRating { + xmlProgramme.StarRatings = append(xmlProgramme.StarRatings, xmltv.Rating{ + Value: fmt.Sprintf("%s/%s", starRating.Rating, starRating.MaxRating), + System: starRating.RatingsBody, + }) + } + + if airing.IsPremiereOrFinale != "" { + xmlProgramme.Premiere = &xmltv.CommonElement{ + Lang: "en", + Value: string(airing.IsPremiereOrFinale), + } + } + + if airing.Premiere { + xmlProgramme.Premiere = &xmltv.CommonElement{} + } + + if airing.New { + elm := xmltv.ElementPresent(true) + xmlProgramme.New = &elm + } + + // Done processing! + return &ProgrammeContainer{ + Programme: xmlProgramme, + ProviderData: sdProgrammeData{ + airing, + programInfo, + allArtwork, + station, + }, + }, nil + +} + +func getDaysBetweenTimes(start, end time.Time) []string { + dates := make([]string, 0) + for last := start; last.Before(end); last = last.AddDate(0, 0, 1) { + dates = append(dates, last.Format("2006-01-02")) + } + return dates +} diff --git a/internal/guideproviders/xmltv.go b/internal/guideproviders/xmltv.go index 43b5790..271fdec 100644 --- a/internal/guideproviders/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -18,7 +18,7 @@ type XMLTV struct { func newXMLTV(config *Configuration) (GuideProvider, error) { provider := &XMLTV{BaseConfig: *config} - if loadErr := provider.Refresh(); loadErr != nil { + if _, loadErr := provider.Refresh(nil); loadErr != nil { return nil, loadErr } @@ -36,28 +36,28 @@ func (x *XMLTV) Channels() ([]Channel, error) { } // Schedule returns a slice of xmltv.Programme for the given channelIDs. -func (x *XMLTV) Schedule(channelIDs []string) ([]xmltv.Programme, error) { +func (x *XMLTV) Schedule(inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { channelIDMap := make(map[string]struct{}) - for _, chanID := range channelIDs { - channelIDMap[chanID] = struct{}{} + for _, chanID := range inputChannels { + channelIDMap[chanID.ID] = struct{}{} } - filteredProgrammes := make([]xmltv.Programme, 0) + filteredProgrammes := make([]ProgrammeContainer, 0) for _, programme := range x.file.Programmes { if _, ok := channelIDMap[programme.Channel]; ok { - filteredProgrammes = append(filteredProgrammes, programme) + filteredProgrammes = append(filteredProgrammes, ProgrammeContainer{programme, nil}) } } - return filteredProgrammes, nil + return nil, filteredProgrammes, nil } // Refresh causes the provider to request the latest information. -func (x *XMLTV) Refresh() error { +func (x *XMLTV) Refresh(lineupStateJSON []byte) ([]byte, error) { xTV, xTVErr := utils.GetXMLTV(x.BaseConfig.XMLTVURL, false) if xTVErr != nil { - return fmt.Errorf("error when getting XMLTV file: %s", xTVErr) + return nil, fmt.Errorf("error when getting XMLTV file: %s", xTVErr) } x.file = xTV @@ -82,7 +82,7 @@ func (x *XMLTV) Refresh() error { }) } - return nil + return nil, nil } // Configuration returns the base configuration backing the provider diff --git a/internal/m3uplus/main.go b/internal/m3uplus/main.go index 712e539..9c6053b 100644 --- a/internal/m3uplus/main.go +++ b/internal/m3uplus/main.go @@ -72,7 +72,7 @@ func decode(playlist *Playlist, buf *bytes.Buffer) error { } if lineNum == 1 && !strings.HasPrefix(strings.TrimSpace(line), "#EXTM3U") { - return fmt.Errorf("malformed M3U provided") + return fmt.Errorf("malformed M3U provided, got: %s", buf.String()) } if err = decodeLine(playlist, line, lineNum); err != nil { diff --git a/main.go b/main.go index 5700554..b3c5e42 100644 --- a/main.go +++ b/main.go @@ -15,6 +15,7 @@ import ( "github.com/tellytv/telly/api" "github.com/tellytv/telly/commands" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/models" "github.com/tellytv/telly/utils" ) @@ -113,18 +114,19 @@ func main() { api.StartTuner(cc, &lineup) // videoProviders := make(map[int]string) - guideProviders := make(map[int]string) + guideProviders := make(map[int]*models.GuideSource) for _, channel := range lineup.Channels { // videoProviders[channel.VideoTrack.VideoSource.ID] = channel.VideoTrack.VideoSource.UpdateFrequency - guideProviders[channel.GuideChannel.GuideSource.ID] = channel.GuideChannel.GuideSource.UpdateFrequency + guideProviders[channel.GuideChannel.GuideSource.ID] = channel.GuideChannel.GuideSource } // for videoProviderID, updateFrequencey := range videoProviders { // c.AddFunc(updateFrequencey, func() { commands.StartFireVideoUpdates(cc, videoProviderID) }) // } - for guideProviderID, updateFrequencey := range guideProviders { - c.AddFunc(updateFrequencey, func() { commands.StartFireGuideUpdates(cc, guideProviderID) }) + for _, guideSource := range guideProviders { + commands.StartFireGuideUpdates(cc, guideSource) + // c.AddFunc(updateFrequencey, func() { commands.StartFireGuideUpdates(cc, guideProviderID) }) } } diff --git a/models/guide_source.go b/models/guide_source.go index cd1b4a3..480217c 100644 --- a/models/guide_source.go +++ b/models/guide_source.go @@ -60,7 +60,7 @@ func (g *GuideSource) ProviderConfiguration() *guideproviders.Configuration { type GuideSourceAPI interface { InsertGuideSource(guideSourceStruct GuideSource, providerData interface{}) (*GuideSource, error) DeleteGuideSource(guideSourceID int) (*GuideSource, error) - UpdateGuideSource(guideSourceID int, description string) (*GuideSource, error) + UpdateGuideSource(guideSourceID int, providerData interface{}) error GetGuideSourceByID(id int) (*GuideSource, error) GetAllGuideSources(includeChannels bool) ([]GuideSource, error) GetGuideSourcesForLineup(lineupID int) ([]GuideSource, error) @@ -119,10 +119,9 @@ func (db *GuideSourceDB) DeleteGuideSource(guideSourceID int) (*GuideSource, err } // UpdateGuideSource updates a guideSource. -func (db *GuideSourceDB) UpdateGuideSource(guideSourceID int, description string) (*GuideSource, error) { - guideSource := GuideSource{} - err := db.SQL.Get(&guideSource, `UPDATE guide_source SET description = $2 WHERE id = $1 RETURNING *`, guideSourceID, description) - return &guideSource, err +func (db *GuideSourceDB) UpdateGuideSource(guideSourceID int, providerData interface{}) error { + _, err := db.SQL.Exec(`UPDATE guide_source SET provider_data = ? WHERE id = ?`, providerData, guideSourceID) + return err } // GetAllGuideSources returns all video sources in the database. diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index 148af04..592d14b 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -49,7 +49,7 @@ type GuideSourceChannel struct { type GuideSourceChannelAPI interface { InsertGuideSourceChannel(guideID int, channel guideproviders.Channel, providerData interface{}) (*GuideSourceChannel, error) DeleteGuideSourceChannel(channelID int) (*GuideSourceChannel, error) - UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) + UpdateGuideSourceChannel(XMLTVID string, providerData interface{}) error GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) GetChannelsForGuideSource(guideSourceID int) ([]GuideSourceChannel, error) } @@ -128,10 +128,9 @@ func (db *GuideSourceChannelDB) DeleteGuideSourceChannel(channelID int) (*GuideS } // UpdateGuideSourceChannel updates a channel. -func (db *GuideSourceChannelDB) UpdateGuideSourceChannel(channelID int, description string) (*GuideSourceChannel, error) { - channel := GuideSourceChannel{} - err := db.SQL.Get(&channel, `UPDATE guide_source_channel SET description = $2 WHERE id = $1 RETURNING *`, channelID, description) - return &channel, err +func (db *GuideSourceChannelDB) UpdateGuideSourceChannel(XMLTVID string, providerData interface{}) error { + _, err := db.SQL.Exec(`UPDATE guide_source_channel SET provider_data = ? WHERE xmltv_id = ?`, providerData, XMLTVID) + return err } // GetChannelsForGuideSource returns a slice of GuideSourceChannels for the given video source ID. diff --git a/models/guide_source_programme.go b/models/guide_source_programme.go index af615aa..53b499c 100644 --- a/models/guide_source_programme.go +++ b/models/guide_source_programme.go @@ -49,7 +49,7 @@ type GuideSourceProgramme struct { type GuideSourceProgrammeAPI interface { InsertGuideSourceProgramme(guideID int, programme xmltv.Programme, providerData interface{}) (*GuideSourceProgramme, error) DeleteGuideSourceProgramme(channelID int) (*GuideSourceProgramme, error) - UpdateGuideSourceProgramme(channelID int, description string) (*GuideSourceProgramme, error) + UpdateGuideSourceProgramme(programmeID string, providerData interface{}) error GetGuideSourceProgrammeByID(id int) (*GuideSourceProgramme, error) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) GetProgrammesForChannel(channelID string) ([]GuideSourceProgramme, error) @@ -75,7 +75,7 @@ func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, progra return nil, fmt.Errorf("error when marshalling xmltv.Programme for use in guide_source_programme insert: %s", programmeMarshalErr) } - providerDataJSON, providerDataJSONErr := json.Marshal(programme) + providerDataJSON, providerDataJSONErr := json.Marshal(providerData) if providerDataJSONErr != nil { return nil, fmt.Errorf("error when marshalling providerData for use in guide_source_programme insert: %s", providerDataJSONErr) } @@ -129,10 +129,9 @@ func (db *GuideSourceProgrammeDB) DeleteGuideSourceProgramme(programmeID int) (* } // UpdateGuideSourceProgramme updates a programme. -func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID int, description string) (*GuideSourceProgramme, error) { - programme := GuideSourceProgramme{} - err := db.SQL.Get(&programme, `UPDATE guide_source_programme SET description = $2 WHERE id = $1 RETURNING *`, programmeID, description) - return &programme, err +func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID string, providerData interface{}) error { + _, err := db.SQL.Exec(`UPDATE guide_source_programme SET provider_data = ? WHERE id = ?`, providerData, programmeID) + return err } // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. From 02b86f81fb6a8c2310b9f01529a4c0b1c6353aa1 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 28 Aug 2018 13:57:11 -0700 Subject: [PATCH 091/182] Update frontend --- api/a_api-packr.go | 8 ++++---- frontend | 2 +- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index d9f0b8b..61c3bff 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -10,10 +10,10 @@ func init() { packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"H4sIAAAAAAAA/+xa3ZIbt3K+n6fosCqV3aoRLe2xfc6xb0TtUhKTXXKL5FpHlcoFONNDwpoBxgBmuTxvlNfIk6W6AcwPSck6titVSVYX9pKcAfr3668byLTBFz/b11fj78Z/Tu5m6+Ra1wcjtzsHF9klXL189e2Lq5ev/gI3qKSF+8buPgmDj0lyj6aS1kqtQFrYocHNAbZGKId5CoVBBF1AthNmiyk4DUIdoEZjtQK9cUIqqbYgINP1IdEFuJ20YHXh9sIgCJWDsFZnUjjMIddZU6FywtF+hSzRwoXbIYxW4Y3RJW+SoygTqYB+iz/BXrqdbhwYtM7IjNZIQaqsbHKSIf5cykqGHeh1toJNnIbGYspyplDpXBb0f2S16mZTSrtLIZe09KZxmIKlLzNU9JZQ+TfagMWyTDJdS7TAunbS8TMkek0GdcFElr7Z73Q11ETapGiMknaH/E6uwWre8WfMHH1Djxe6LPWeVMu0yiVpZH9IkvUOQWz0I7Iu3slKO5l5c7MD6s6r4Se7E2UJGwwGwxykSuirqI6h7a0TyklRQq0N73es5jhJ1u+nsFq8XX+YLKcwW8H9cvHT7GZ6A6PJCmarUQofZuv3i4c1fJgsl5P5+iMs3sJk/hH+bTa/SWH6t/vldLWCxTKZ3d3fzqY3Kczm17cPN7P5O3jzsIb5Yg23s7vZenoD6wXQhmGp2XRFi91Nl9fvJ/P15M3sdrb+mCZvZ+s5rfl2sYQJ3E+W69n1w+1kCfcPy/vFagqT+Q3MF/PZ/O1yNn83vZvO12OYzWG+gOlP0/kaVu8nt7e0VTJ5WL9fLEk+uF7cf1zO3r1fw/vF7c10uYI3U7idTd7cTv1W849wfTuZ3aVwM7mbvJvyW4v1++kyoce8dPDh/ZS+ov0mc5hcr2eLOalxvZivl5PrdQrrxXLdvvphtpqmMFnOVmSQt8vFXZqQORdv6ZHZnN6bT/0qZGoYeGSx5M8Pq2m7INxMJ7ez+bsVzOYD942T5O9a4fhn+/rl+C/jq+8ZOyjA7mZruPXRn5yCyfceTN5pvS0xhZnKxs9I8owkz0jy/xlJzNPP9vX346vxVTKpRbbDF1fjl+HPFkvgc/9+QsNBdjV+mcK/CtUIc4Crly+//cwrO+fqH775Zr/fjwVvMdZm+01IM/tNksB6urxbsbuuF/ObGSnp3fpARllO75eLmwfWPeWnbmar9XL25oG+SRJ4NYYbLKTy2TJOWI5R0GMUsqBC4bHBoaksZ02XYVBo46HCYG103nig4YXoyRYiSG9hIaftMIfNAVaY+SVegdsZ3Wx38FeImBixbyiTNidCdVmt9woNZSYqJ90BRON22si/8268yrnn3U44wnIGcUIP13my3Ry3ooQpL3siQKNItZD4IuM1ogSE52XJi2i3wyAaAQhvm2nljC5TIJQLH0oWNyU96NtG5Wgg01WlFa8THmP89qv4zcbwVhuWoW5MrW3EXBlsLju/jMIaI1bCwoW89C/qPRpCdUOwqg1I5f/mIpOJxiI9x2v4H1hzA5VQYovkLtrTNtkuCJXCfoes+ObgJRe8cmeRvaTY0QYupLz0LrE7WdM6hSwcF8+MFr747uU/X/Jm2mAwt1+mcYTDXNTsThi0cT15CRtUWMiMMHqwdk/G6OSPuhnBhTb8lxld9v0sFNviUeYNrWSgHxH8Oj6hyaQlIbpqYiM1IPXZFUeBtdKNyXBESVQdx1VtsEBjMPe/FmznT7QBl2OZcdG23qVdXd80XN98Xff1suUXlreDTOeYDtkFL+J/TmOGF3LbmB73iEIvuOyeCk1Uh78zaJuS86AwuoIKs51QMhM+EZwRytJzIoYPf1OGjwUI8GbhxdKharzCkXqZrmpJaaM9H/DqbVGhOaVRHTJlWj16PGba4fOzwlwKcIe6U/eDNp9Okn6vzSeWlTGGoqoLdamiAiHQvcGCOpXIEcSjkKXYlDG/e5iTEkpSsGUiBI4IeX/EXiJw9RgKg4ZzVCnySItIUl7gQijAJ1HVJTEqqI1+lOE1em5S16hy+QQbLPX+Mmp/g0Y+CicfEcgQdnTscVr/vO5Bb17H6x5F3ghL7lKcbjntQFFudOVxiDZiF1HM73cy27XJjrl02lA6G3yU7DyKV6VdyAbAUmy0iZ+0iY7t5wwvRfUKLSrHFhfEO0sOftBGbqUS5Rkvn6Ksx6BikN4pHJstWI0iN/iLFw91wGAlZMhBrIXhyCB7sAIVGiwPUEr1iQ22kYrjQokKL6ObpXJoCpEx7KdttWtNeSIQWQV1Ef18TeAc6vRZHx9He5uW7V6t2UJaxZrYykBLDfzA8ZoHJuHX0d4i/I42nxU77YW/IxzXSpSlh2LbbCrpAjhE3sCxxDL75k11ojE2nxAD71cuXF9E/z7NIKzlzSm2N7gTZQG6+Bz1+LqKDaNWnxGv5Gt2C7a6ACwxc0YrmaVk+40oOW72ht5STB4aFWwOFPGdqbEzENnH2S4t2Oo2/WJpCcjUX1+rnjxQCVnSq6W0zqb9AtQSGXuwDivbAbO0tkEqChlXu/C7dzhVMc82WpbUN3XaAsXA7z0bk71yabPGcq3m/SrGwkD9PjCexVKDT1H5oZYx+jKtbC2zRje2PEAlzCcCNtNxG0+W0MqtYjyXiv3C5jwbdwRGo7l2IKCfk+PRcaIeceFW4Zhpv0JY+mbzPfdwQ9gJCxtEBQYzZITeHAa7xGSz+EuDypW0ZaZNrX3ZJYLaSzMCmqsxvCNCRFt285bIiWA1bOjPthttOvXRFkW2g55hBoMZru4fdQOCmFmNrhGlD7a9NmW+l8QWlFYv2NdWPvLHF3GGY/RBlO7wojCIKUhj8FFnBNBHVTl0ZbRZ7IQwJRJXU8ye4FgEaZ6lZOWBgrIuxSHtvqnR+LJ5NFrpjV3acG8xlontyW5nyjKjBznlTz2n3AsC0//VHrnApwxrR2lkXUw5P2bzDcsl1F7Lnscq8QlT2IlHZH7mheGuVhcF8TPNw6w0/FdWtTbOO6PN9EBsA5tjGPE6kereL3FHUdclT5FUefC2JWQKYmWlkJUNz7ZqbQ5+ib5NW0RUmKG1wkjOwcJItY09B0pfyfqpfWEvQZRaYahvma42UrX8m186fsGr4nvOUDd5VkfkbChY2GBPDoiVawyzgjweehXrpKPobR3h5NZvL7aCfmYAC030RVeAAhM22toXbCZSINMNcR//WSoQUIq9baQjJUvcemAXrhU8VvYjvPsSeDHOe6FtaH3jKlnnkENUKPqgYnbpduhp1DDuPOGJDWLIiNgOdLkUCljkRB7xKRHJYz42RDt3zIVrQ621qbTcv+WU7N+OYYn9mcyYt63EoUOtY4wZTHA7tPkCO2M3ENnDXDZV6uOGGImfOXsaM2hifSH+DEqlXbPChoiBVCG6L41+fddz6TVsrIMtSUqC+Z7AYCZriQRIfaoaujb6d6Kgn9wf8/0fuRz6/Ta9/fzIpKO91OXwFJ/HKYYCxuhKKooK39XZdmsCrzZ0aUVqordsAvSr9HfNersadELyrD/Mottmmjm8Opyo1W7abtaf7Iext69zaYjilOAuR2I8aUsGOBhdl1JBJz8GOCPLECiHfMtjYlyBBcs1088aDSnYnq4I42IRikz7WMG+qfJLAqPW26EdI9eO5ov17Ho6AodPjm1MqRXWJ3Lc7tHPoF6Cn8mHE3uyj9qFYjMowKDIue/rAgzPGpMAR0iFnckDWHHeexVY+PRrrNkuct6qZ63JoSUclCgstTrdxDu80OVjXVJL+kMUUUT5Ogt3lunFkP3i/j/24XkQUl3mDoc+IIsOQ6j0bbtadrq6NumxbUXkZ725UuDvZ6xTDDKCCcAjGu8gt5Mmf0HqHVp/KG0qal+JGKAwY1jvfH9E2HRs3J6Hufj7xrYdqImy104Sv+iLEjLIn+cNJt1tGRB5Tn8b6kb68deuEYUOlvmamE+9za3Me6HCnY5QtCGqvKkiyRxESAQO35VFFw7xis0axwiiPJ80PCOCDfpKbpphtHmDnJ/+nzVMx/uZZPLo25fwo1FTa35aIsjfF1YbyCVxzAEjPcOz4xjtzGGLX6R3zqKLM5KkMT0Kbt8On2kV+rOwNmV4Ndq4nZx1m5+c8gxqacuOM1150ktx0xuJtH3EEVvvOeE7bkTiCS33jh1vs2N4UCVay47Cp7qUmaRmlNfrHTKE+cLhmPX1xke90dFnx0WRjdNuxyOU9tS4m+p+fcsUD+RJxF6A+AU80czjOR29PdeOXmnPPlw86KZmiVJzy00XFQYWyzY1Gos5+kMUCvjWDWETzw78CNJh165sDfoQP4Rc4E4JnzBrYZvhtDWEwa0w/kTmuDfgufr3Y1hH+mAJ7np8N9eMiM5T4/7ZvL+U4AWmt/1hgKjQ9tiIpSbNPMoMIXzUBkK8+odjgEZp0zjpCW2jwV8aGc5dqCxbrbgwsxMb63QlzIElkQpytJmRm+CA0BTIrTydfsasib4K+H4G1slCfx7DjbTc1KChZz4IQ/Y4tOHeirk5+IaSe2BqfmKis9+4teimTmnnpJDdthPzguSk1n3YMvaflc4O3XkJms/HwnUGeDNZzVbepEcXG2bTcEugPageXHRA6U9In2pD6gUdJKNG3htDpmeurqR+TO1NFO5nHEGnLmA9W99OU5gv5i/6NxvSkwsS9PrgjgSvcHpPwldNf7JWYkk9lK21spLn93y24Tu1fniIuja6NpJoNCtaQMOzSI62Dkl788h4MaipuJvwICwto3V7W4gzkIE6nEXyrLN/GHnaXFKk/WUMt90dIF3ArRQbWfKR8owqKOAjxSnJ4FdQGkoeJ7odanNoxxzxBMhp4/ptu8JtKbeoMrxM21PgdDAmDROXX43sC1/sLeRYyg0TMRZsa7S1Yf4ft3MgMmf5zPh8JnhcHJQEbWDj3VRK3jT05exMUYntcCJO78Yj8u6w3NaYyTjSkiqTORFRP5Qn+uHnpVKUccmIvNlOkGnQgDD+LJmqcai5tindcePJNmxaDGn8N1IFB/YQs+vbL754VhwlIoVL7cNzq3W+l2U3o/sE1um6Flu+IVbVDYlcCFk2xlcXURaN6sgJl7STuxCZrioK1L4d/KZoL1OOOqLSx2MvXqEdTov8UfJhYhGuMFgrg/LxmD8sTrH+1zFMMsJ50j4iKu066QpuL/w/7IhkD5NyeLT2xSOqyByzndZ+zsjTxN4RNE80QUCBjBcpCJZOqAy9+LUfNAZkO3CUYaWkC1nXnm+WUWrQmzJMfmy8iOcv9XHsSctFJ3Q/0vYOS3AM7/WeOhXf4LWGYiv2lu0049scqmxPFFp+HI4WeEAaviaI7ACSZWWm0p1ERJzuJjQ9t4dpK3U0svC4S0ntc5ptUgSb5Figyv3zO13mZ4bRwlSMNJEKt9aLKdsY050whYmssBYNpUkYUqanE9nNIRCGqMqBNO8s2dLufS/2emSvlYOCdTq/oQp57opXksDk/n46v5n97QdyGnftdV0ewlF+/zoa/cZi7MMpDACsv/LxNFwnGHb1ngJrWaKpS0Jg32WlXU9dSCxzC6iyUlsP5Bsjsk/oLIz+/T9GsY0oRRYr1yGGDqNl6MZ6fe0YLm60+pf2/LzNw7jwP10C983cONqdbsqcqHgrQ+DwvfLbnl5SRtiDcuKpPS7k9tpvPoYPCKK0Ggz6p8Mc0iMzP+mjxFpmmL4lYmJYx6Iajx/7V0r9lVt/jEavjWojeRhMyDoi7B+eD4aLHyQiCivDGXWwVzyZbEcj3ZhBmGwnHz0Cnlxz/u70mnMKc3RFKZ/ixzuZGW114eBam3oc25kY9jZJYvTkvdZnGFdp//ZjuMYcLxpe/pi0rQUhgq9ZYW4dmblUoYdkdGxDrWUyLSj5e9aDUW0X3cL5DPi1u5W3s+vpfDXl653JV1Huz5GMcPkq6U+6Tq/9gLSDB86T6t/JqCObHiewQhxsH+OeuUshMyiF2jZii7DVj2jU8cU2Hmt0BNyeajROktyIbVOK138a/3l8de7aPVzczdaX/cv3//WfbVB+D3OZ6VJYeIOPIvulEX/s/Xtqw/+4+/cgVfKH3b8Hp5M/5v59d3qT/I7793Dm/n3yP33/nunj/4X797G3TP6A+/fQ3b9Pfsf9ezi9f5/89vv30L9/n/ye+/dwdP/ed4+vX43/Ov72HwGUb5+x5BlLnrHkGUv6WGK0tY+o3OtX4++e4eQZTp7h5BlOfjucCKeJmLwcv/yHOp1nJHlGkmckeUaSHpI4mX06MJS8eoaSZyh5hpJnKPltUPLfAQAA//9OfLZ3M0kAAA==\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/+ybT0gcVxzHP/4p1qLt4qEUW90VqrWnSileWtmlx55KDx4KtaUt1UKp5JCboIeQYyDkzyYecsohkEPwFA+CQXIIuQQSBE/GRBOEgAbC6kY3O+HN/pY8htk4Mzu7bxLfF748dpj3vt837+2b9+c30EIbIyMqzXBtEEaBTEZ+p2B9EFKpyu+pdjg9CsPACPAHlesuvsTCwiIcPgK+BXJAtsn8Gmivw/vHQB7YBfYM8ClwAmiL6P9noAg4BrkJfBXR/5+GvTvS9t9F9D8EPDDs/4b046hQr8FTwMWAvABcBV749IPLIcpRPAn01eE9KgaAxx7/S8CHDdTskrqm66Qq4wcZO3T/t6U/9sdQfpfm+wNgHFgG1oGNGLgFlDz+94FHMZS9Ll7HxftfwE4Cxpmw3BHvawnwEpVrPu38LtHPu3pfrEgfSxJXxNtRdVL39QCdCWOPeDvK/7LcnzR0ijfr3wysf7Ow/s3C+jcL698srH+zsP7Nwvo3C+vfLI6L/yfAfMh91mZwXrx5/ZYD1CmpLMtepWkfUam8zybgjCgKi+K9G5gBHgIFQ+d0YVgQrzPiHTnfGwDGDJ2TBmVOPA7UcSZpYfHewHERIKUyarnprE86By3u/aW0o6W3qPzT5nADkWqiQ8lsJD+thWr9qvUN+lyHwY3OyulxWqn42vcYoCPmc5ow74VfgJtUmj0ungc+C6CtesndBs1N/g6gr57V9QZo7wI/BXz+XwC/AVPApA9VPa5oZat5yzTwT437FX+Uc3U/dHniD/qAz4HeGvwU+F9bI9yTWKJa9/dKeVWNfi1WQc1fFiPECzzT6v9S4kLC5F8U7fsG58pK+5Vn7tzoea6+pvBqT2tz3UZwTDT81jV70h6NRla0/PRzTdDPWX2rb/WtvtVP1Ph/AJyRudK/DeKkaBxouocG5x+HEj9rSn9JYl/Pyh56nOuNt3FZNIekT7QaiJtrbUJfTzwcDSVIF4VOKes45ay7/VK9N+04xSj8xHGeV8twt3M0DMuCM6PvU9TzZcrRSMv6TR8XpoTe8cLv+4YJieEvaCzJWmxPu6bm2Oe03aluWdd9A/wK/C5lqfQOsA38J+vOCeH3kkflXZA11pbEe+ssyFiy6bm+KXkW5P++Kt/tXPIwL2dRftdXtfEiH+F5523+2PIvaOcNQZjV2n5b+ul+SJYk71jEd/Ok5K0Llb1N2GiD8uyb69lSber5XgcAAP//wTJ26O46AAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/6xTXU/bShB9z6/w3dfc2NzAhVB5jVq+AoiGj7SNeNusx/aa/XB2xg6O+PGV44q2qEKt1Cd7zsyZc441jv9JnaS2gqAgo5NB3D0CLWzOGVjWASDSZBAEsQESgSyERyDOaspGE7ZtkCINyRy0buOoLzp4KRCCwkPGWcS+b7DCAGeNgnXlPLFAOktgibO1SqngKTRKwmhb/Bsoq0gJPUIpNPD/+jVa2cfAg+ZMSWdZ0NnnTBmRQ/Q06rFeNxNNV4ZKuqOGj1kyeOH3AwVRhe+iKHOWMMydyzWISmEonYkk4lEmjNItv3NLR+75XuVWPYrn+0J4GM5BFsNrZx3r3SC1GrAAoNc+f+i8Eq4Rwk5crAGdga2uBw0CAaPm/3Ac7nQ+InRapaFEZIGyBLlX1HKGhdid7I3W9v3xgbbDxcedT1epvGkuG1pdTHfLWYmHlb2yq8PVYn9yYRbN7HwzvqzP3Kk6LueTsn24XYw3LJDeITqvcmU5E9bZ1rga/36Mn2Z+HWa6NF/mU9EeVng9WbWb06sbOXHpdO8EZ/UmhZKsH87O6MTM5MVnW+R3cLt3/vBhelCvZZntvxHmzSg9snWVxFF/9fHSpe32I4iqGnnnKImjl9dBjNKrir4dIMETRaVoRI+yAL3kzNeWlIGw3K7tW8nvECun20xpjX9ONULZV6yoTxJH/W/+NQAA//9rvAnH9wMAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/frontend b/frontend index 561b58e..27ecc8b 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 561b58eaee6722bc276d779f178c16f4042d6e8d +Subproject commit 27ecc8b47b68f9b6dd4d8886817b3fb1ff2960b0 From d3fec5fd653045bec7c22ba3b341a0e6eb80cfc8 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 28 Aug 2018 14:36:42 -0700 Subject: [PATCH 092/182] Minor fixes for SD --- internal/guideproviders/schedules_direct.go | 15 ++++++++++++--- 1 file changed, 12 insertions(+), 3 deletions(-) diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 0212dbc..ebc0ac5 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -443,10 +443,19 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program } xmlProgramme.Descriptions = make([]xmltv.CommonElement, 0) - for _, sdDescription := range programInfo.GetOrderedDescriptions() { + if d1000, ok := programInfo.Descriptions["description1000"]; ok && len(d1000) > 0 { + // TODO: This doesn't account for if the program has descriptions in different languages. + // It will always just use the first description. xmlProgramme.Descriptions = append(xmlProgramme.Descriptions, xmltv.CommonElement{ - Value: sdDescription.Description, - Lang: sdDescription.Language, + Value: d1000[0].Description, + Lang: d1000[0].Language, + }) + } + + if d100, ok := programInfo.Descriptions["description100"]; ok && len(d100) > 0 { + xmlProgramme.Descriptions = append(xmlProgramme.Descriptions, xmltv.CommonElement{ + Value: d100[0].Description, + Lang: d100[0].Language, }) } From 8ad6f3a7c1af9510f5c66cccb8b078469e436256 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 28 Aug 2018 16:55:31 -0700 Subject: [PATCH 093/182] Changes to match latest go.schedulesdirect --- Gopkg.lock | 4 ++-- internal/guideproviders/schedules_direct.go | 16 ++++++++-------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index da9e07a..357ec96 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -307,11 +307,11 @@ [[projects]] branch = "master" - digest = "1:189ca3d42cf31e7ae31a31e17f4a860c8c9f1f164e28b242b3434658d2f6e41c" + digest = "1:9ae6456cbbd0aca86266e34fad46fcdb27ce7492d7668a8c5d84e5ac0da7aa1d" name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" - revision = "34412a2eb0519d921a72e24a3e17e8a335dcdab9" + revision = "49735fc3ed7740fa11ebaafbdeb8ed466fc9e239" [[projects]] branch = "master" diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index ebc0ac5..5017fa1 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -216,7 +216,7 @@ func (s *SchedulesDirect) Refresh(lastStatusJSON []byte) ([]byte, error) { var lastStatus schedulesdirect.StatusResponse if len(lastStatusJSON) > 0 { if unmarshalErr := json.Unmarshal(lastStatusJSON, &lastStatus); unmarshalErr != nil { - return nil, unmarshalErr + return nil, fmt.Errorf("error unmarshalling cached status JSON: %s", unmarshalErr) } for _, lineup := range lastStatus.Lineups { @@ -417,7 +417,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program Channel: stationID, ID: airing.ProgramID, Length: &length, - Start: &xmltv.Time{Time: airing.AirDateTime}, + Start: &xmltv.Time{Time: *airing.AirDateTime}, Stop: &xmltv.Time{Time: endTime}, } @@ -486,8 +486,8 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program } } - if !programInfo.Movie.Year.Time.IsZero() { - xmlProgramme.Date = xmltv.Date(programInfo.Movie.Year.Time) + if programInfo.Movie.Year != nil && !programInfo.Movie.Year.Time.IsZero() { + xmlProgramme.Date = xmltv.Date(*programInfo.Movie.Year.Time) } xmlProgramme.Categories = make([]xmltv.CommonElement, 0) @@ -545,7 +545,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program Value: programInfo.ProgramID, }) - xmltvns := getXMLTVNumber(programInfo.Metadata, airing.ProgramPart) + xmltvns := getXMLTVNumber(programInfo.Metadata, *airing.ProgramPart) if xmltvns != "" { xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmltvns}) } @@ -606,7 +606,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program if !programInfo.OriginalAirDate.Time.IsZero() { if !airing.New { xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ - Start: xmltv.Time{Time: programInfo.OriginalAirDate.Time}, + Start: xmltv.Time{Time: *programInfo.OriginalAirDate.Time}, } } timeToUse := programInfo.OriginalAirDate.Time @@ -641,10 +641,10 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program }) } - if airing.IsPremiereOrFinale != "" { + if airing.IsPremiereOrFinale != nil && *airing.IsPremiereOrFinale != "" { xmlProgramme.Premiere = &xmltv.CommonElement{ Lang: "en", - Value: string(airing.IsPremiereOrFinale), + Value: string(*airing.IsPremiereOrFinale), } } From fc1a441de64e52f8c5913edc7797a69207edc590 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 29 Aug 2018 21:01:08 -0700 Subject: [PATCH 094/182] Checkpoint, more work on guide data providers, update the frontend, minor bug fixes --- Gopkg.lock | 2 +- api/a_api-packr.go | 4 +- api/guide_source.go | 89 ++++++++++++++ api/lineup_channel.go | 24 ++++ api/main.go | 7 ++ commands/guide_updates.go | 22 ++-- commands/video_updates.go | 3 +- context/context.go | 25 ++-- frontend | 2 +- internal/guideproviders/main.go | 45 +++++-- internal/guideproviders/schedules_direct.go | 130 +++++++++++++++++--- internal/guideproviders/xmltv.go | 32 ++++- internal/xmltv/xmltv.go | 5 + main.go | 14 +-- models/guide_source_channel.go | 2 +- utils/main.go | 6 +- 16 files changed, 351 insertions(+), 61 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index 357ec96..c8b89af 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -311,7 +311,7 @@ name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" - revision = "49735fc3ed7740fa11ebaafbdeb8ed466fc9e239" + revision = "9386c019cdd72747f7056ed549e035e3cd1aa08e" [[projects]] branch = "master" diff --git a/api/a_api-packr.go b/api/a_api-packr.go index 61c3bff..8ca0c66 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -12,8 +12,8 @@ func init() { packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"H4sIAAAAAAAA/+z9e6/jOJIgiv//+xSaU0hUni7LJcmW7WOjCt1Tvx5sA119galZYC9qcxuyRNvq1GslOY9OGZ7PfsGXxEdQL5/sqb24nV2ZMhmMCAaDQTJIBr//w7/8/6w/WP+a53VVl0FhfVkv3eXK+nip66Laf//9GdVHnrkM8/T7Zwz/U168lfH5Ulue47q257g76z8uSMDzp2t9ycvKCPwa1zUqF9ZfsnCJgf4ahyirUGRdswiV1s9/+Q+Bh7i+XI+Eev16rL5vGfr+mOTH79OgqlH5/V//8tOf//bLnzF/3y+zs12hBIV192XnBcpQ9KOQEuZZHcQZKm/HIPx8LvNrFu2/OZ1Oh2NeRqi0wzzJy/03xxX+Y30ThqH1TfSC/9ynkthf8i+YUN7Y1SWI8td9lmdoMhoLJwZlmb/e6rzY217RyMzWZZBVRVCirLbE729eXl445Gsc1Ze9Y/lFg/97gIm2VmM42Gw2faSEhGNe13lqaCpKi4LYRLHsMojia7V3DnJmgk5d3kjSdV700q3zwkAU54ygeMrDa4WifZbXHzVGnntpM3V0nC0iOtqqUpxVqLYcyy0a8l95PgYfnQX+s3S2/vPCsfCfVZflepuF5/uLpfsMsxnFVXBMhvsLZ+r0gv8IuIiSXILK/hIkV0R+FUkQokueRKi8RXFVJMGb2gusseTaTrrHFa7yJI5IBz2kcWZfEG6h/WpTNIcgic+ZHdcorfYhympUDpHTuyqVrCPLdfM8hIgkkuoLddH5ORRBFMXZmWjP3nWkHjkasSZhJqkgCOAWruLsnCBY4IIAJxc2MhdnxbW+kUo6ep3bFNK79j5OwibOaKDSa1LHRYLGKq2RL5JmVGlAzdAK//lncCXkJsERJTcmJGq8+zkYr5JSW2yFphgl/2lKQIV9yjOsQ7+h/fIFpYc0KM9xxlu+aHgCteMkBWge/xR0QzUzut14KNkFDzmn07tXo8vkTfzeWvQuTJmUiLb312hfITcO82zxFfHTGvHRJM6SOEP2McnDz4ev0VeMdeSDhtb+0Q4Fp+hrk1/ituTzBNqPvr7+qzwQupwJati/Jg90POHKzGzFSjBfhIXV+7a9OMIy83hQWPD7WSBowgQFpf1aBkXRDdUvL9oESoLrUpi2cRVzHM89apOGIs4yVNq/5Rm6KYNrr43vpvctg3pxuobwhkpSRoVVizBZZtzLywIdhV64E5dlWGzwUaGq3xK0JxooL37Y0sfylrwGUZkXUf6a2UWQoWTSlHPkTFGmoC13iDq5jvPhoMsIbfAfPiySlZ8L8q1htXQYOvkkGXlRx3m2T4KqtsNLnER9y6t1t9YEFljrIX7qvLixHqLW0kRGXVLpHIDyYVSGRVTnxSj5nOJSFdBEtgE+ZMoXFETq6lbVMz6gYcXdjsB5yvNaWrk+ilAQz02WNSzqQeHiHlbc7Fd0/BzX9rXCXZY0DVkXHuw0/w1KrfRELYHXbYfXxHgxQeacr4itLpwDVR2xo/rr50N4Lau83Bd53C4V59SpU55ubshQR+gUXJP6PVCnQfkZnHSi48lng+2DJKhI4ZktnYCLct04zhyicZ4ZDK7eSLvts9a2M2lC1WS0V6uVccnxftSEXDaRfR9hjleRQ1ffx2l1mk6RhmH4OFJqdaX5lOfNbnLyWQdnZSXUzWu6lenO+SDp9tpx7vsyz+ubbR+TKyKOuOPpdLDtOIvic46nMq5z8g62XVzLIkH7bzantRe6OCHOPu+/QbsV2oUH2y5RtP8mClf+2j/Ydl4G2RntvzlFW+SuD7b9hpIkf8U9IHSd7cG2zyVC2f4bbxdsSYkaBcn+G88JX15wdvgWZPtv3G3gHXcH2369xDWi/QcXDd7232zCrb+N2E87CsrP+29W61WwdjBzZZwG5ZtQoQqFeRaRtLZkdQ1DVFUCF3F2ykWyQZnhXtmxHeF6lUJNEyLJb06708spIAASI8cSBZ+J6bWbaq+kVOne326KRk5No/12s1NTk/P+5cVTU5tk73qOQ5JJy56CNE7e7CrIKrtCZXza20FRJMiu3qoapYt/TeLs889B+Av5+W95Vi+efkHnHFn//S9Pi3/Pj3mdL57+G0q+oDoOA+tv6IqeFn8q4yBZdEgXT3/CSK2fcK+w/pzm/4ifOjx6wi9v6TFPnhZPf8vrXCql8J3mWV4VQYj2v/zbz3mW2/+OztckKBc/oyzJFz/nWRDmi5/yrMqToFo8/TU+ojIg3QCDPy2efsqvZYxK62/o9WnRorv/YbHfB6calYv9/ohOeYmoNzT+DbdvO0dp7pc6TW5kyc08hu7S9Q98PK9RQ/uSHUT/uFY1nffh4ducg5cLpyR/5VP3sMyT5BiUHdKgsC/x+UJUSd9yuP8RY/kSo9ciL+sbne1H6EscIjr1vwdlHYcJWgRVHKHFKT6HATEN+PNaogWdNS3ohGxxIQPiIg3ibJEFXxYVCslwxT0OxNVwP+bRG5sR7Z2D0Ea/d4XqzJ1bolS1dwe5aX0+Wniu53svB9KKxJ+9x3YZGjBPp/uvdXCMswg1PzzZ7tOnPdkAueXXGiPfO/8Sp7ilgqy+X9zFxVtcVovLenHxF5fNTVjwOMrsfumXKL1HySJPFsXimvTB4rrdg+Ox/DUK6sDOy/gcZ0Fi13GdoE8LkkO/b6ROEQpz2lH2ZD8ScyprNQRhRXldo+gwCMAmgheUFPJyZu/cgygqUaVNr9vGod0iy8s0SKTmibMLKuP6nidWjoViXZPFlXxf8beC0LlHtTTZ2DrOPYpugIy5LKnj/k4U/n9f8xqxDtPqveVYRNDRKbsJvMZ1kMTh/bio6jLPzhLVI3Gk3KvrcVFdi1uRVzERWYmSoI6/IEE/t/4Hqb7O4QvCPTlImAoegwphAIyNLzTtpeej9I5xk0XzEv8Kbt1GGh7u1PYiywdNl0XvgkEV7OpzXOzz4z9QWFf3QHbSOI6/Oa7MynEPyJbgr5cSnT4902/ecz49L3pzaZ8agBG5YcoCVr2fEbX73sM8QovPx2hRlGhRBWlxE83f+w5MorlC6b1olc/Y6w98PNkH1zrvHWHucXq+KTqVxlGUINmbRGRUfTnfWtSXOIpQpuojLXuv8ZRY8FwlQVGhPf+4s8HnJrrjllvS7xS3IkvlXjM6LVNNMENn47FtTwve68tNAON24nita7zskrZPHJastDK1W5ZbNAeexLsAAbRLzCfhzMJyJg53imlBvLQLvrJc0KXPAjMUlCiAB02unl1z8xTI4omEukb5ElfxMUE8l9KlgiBd+ZSXKW3LX+u3Av1QogrVnxb0R3U9pnH9acEK42mORXNoyqfWZxEUBQrKIAvRnmbdJbj9nvgwqJSIP3YhkjNmMwaAfNZAWka3NQioK5ENxRxeUPj5mDefFkIibv78EzzJ6/ZRRDRRUCMJBU6o4xTZSR4GiZSV5ll9kVIwICjDJK5qPLFs9UPuvyUi2sB72v0UoySqUH1L44wfa+n4PbTKxfy2zj1BZ5RF8uyN+bLJFDQNGlv4qaKSB0bBGtEEQDsPssElSzObTtrpIH4vyvxMhnzTeEZFll3TIyqxRjCpUe9+VWCuqJoaAPNrLQPy7X0sUoa9QkEZXj7xHm/np1OFanq+CGgmod+wkh05mmCHGDCRWTPBdiMQpBOEWFfmFCfIvhZJHkS8PrghWhGbe2Z+rbGJgDYL79U1xWvgNhMrIvEeqB7BGqVFEtRIPsHyKx0DPkmpwtR2eXEXy4u3WF5Wi+VlvVhe/MXyslkYp7y6okG2UXBnylN1T9Y7Qv/iCvvuHp0/Y54unphOU1eLy+om6veWga8Xl/VNVfw7rs7Fl9I9lrHBlZKXGfdlgoJIh5bqtHKc+5JJ0xY53wCQau27kmLd/CVExVxWlMB6YllRSKtxZS+laIDDPKtRVhML3E551dFN3BFyhbm6OAPitu8A7gOIrlX3+b6s0iBJFuTvW78vbJkG5ecF/qsdepYepqevAsPTDq3uS9qnSK9b0B/XjAxSin8Pi6aqxfFLLEp6JdyJNTAyexW2t55v0lETprxxFtdxkMRVKlT5xflwUGYL16JAZRhU6L7sVkHmlZrUD7oCfFtGHoNkWUuTPKBw65ZhWrJ/+p+e466t/+k4f3Ke7ss4Pdun5BrjBZ00oImWn0DVl2t6zII4ERqRaOvYDdAIIQ9tlGM4DEcfcbZ4hNuRZtp4Rg7ZQ6nntNB8Ki23oSxKvFoR9Xq79FsQ5p19zcuIeg335G8bJ9yDH0lR2ap+PkaC2EqUWsu13P4SASJATazMmaIKEGvN52NkiTQcUbMcpU/iFXwhSFTTK5EVShTDW4pIDPOWTihs2rIsSmTTxRNZ4eC25scG1w5eKfB11htbY92X3ZEzfY7FT61opydc4UBY2SqQ5JUgGvXHFEVxYH3spoLEXfx8E8h2CuljHu9AIeJNNhTaeoZCxNlsKPSyMRSivmhDKdelDHaZrEN/Bckty/y1VZtTgpoD/oucv9jjv2QctoiWICEp92WW2+drXaOykq2so3iQBMAfl2GeLMSEX8MkqKo//BDmif1J2Z9RTo06d1oag7rsH4f9y3979F/2z4r+s6b/+PSfDf1nS//Z0X9e6D9YPPQrOfN/OS385XSfQqrXfnZfq/Zr3X757dem/dq2X7v266X96vhJI/4v5wd/Od2nkOq1n93Xqv1at19++7Vpv7bt1679emm/On6qlP/L+cFfTvcppHrtZ/e1ar/W7Zfffm3ar237tWu/Xtqvjp8m4f9yfppOPZpOQ5pOSZpWT5pWVZpWW5pWYZpWZ5pWbZpWc5pWeRqqP4BXU1xwdsfVXe0QNNylidrfSBc9BlVc4WEB/ziX+eveVQbde6vHpATx0hIrQEGYQeAl6GSL9JwOfLdcsf+J62MhlZbwuhLuZrmh/9tKS2ohmZZZdWU8XwT1fAax7iBWK5ARMZmW8bsyaxfkREymZTZdGV/yA/hchlsBAhaJr8lk15XZwDLZaDJ56cpsJZlsuUxcR2gcWCg7TSiu0KIvsFReNKm4YqPq/pH7kk5ayPmoG50a2i5PxdNuluiueKJz464YluByEJ7gsQSPJ6xYQotjzRLWPMFnCT5P2LCEDU/YsoQtT9ixhB1PeGEJLy1jnFW347VltuXW5ey6mF/iNbHdmzjgSUrBIDwJQu4XDGQlgZD+wHLWUo6s/gzEl0BkbWcgGwmEaDnL2co5EP87CWQD8f8igWwF/l1Hlg9UAVeWoaSZfRM9PApMM41s1JhmHfEoNtlA4vFuho3Eg+OgmcTj5gxLiQfZGcYSj8iD9hIP1jNMJh7ZZ1hNPA0YNJxkSjLDdpL5ywzzSSY7oyxolRqMaJXCdrRKdVNKtFKxpkTpFINKNEqxqUSBFLNKtEOxrKTpFeNKWlqxr6QZFRNL2kixsrRJVENLBa7aWipOzdwSUShLjC5r2BgTEQ3aYyI0k0km0hu0ykSeg4aZSNhkm4moB80zEf6ghSbNYTLStF0G7TRtKKOp7l1f4xXENFvNVhzTbDVeAU221XitNMNW44XVoK3Ga64Zthov0GbYaryaG7TVeKE3w1bjVeEMW42XkIO2mixnZ9hqsvadYavJQnmUrU4jg61OI9hWp5Fuq4lWKraaKJ1iq4lGKbaaKJBiq4l2KLaaNL1iq0lLK7aaNKNiq0kbKbaaNolqq6nAVVtNxanZaiIK2FYTiQzZaiKiQVtNhGay1UR6g7aayHPQVhMJm2w1EfWgrSbCH7TVpDlMtpq2y6Ctpg01xVZ3bs3ETs7TbDXzVk2z1cl5hq1OzrNsdXIeYauT8yxbnZxn2erkPMJWJ+dZtjo5z7LVyXmErSau0Bm2mvhNZ9hq4mQdZauTs8k5cYZtdXLWbTXRSsVWE6VTbDXRKMVWEwVSbDXRDsVWk6ZXbDVpacVWk2ZUbDVpI8VW0yZRbTUVuGqrqTg1W01EAdtqIpEhW01ENGiridBMtppIb9BWE3kO2moiYZOtJqIetNVE+IO2mjSHyVbTdhm01bShpthqYTcpsZuJ/uFmjou4meMlbuY5ipsxvuJmnru4mecxbsY4jZt5fuNmnuu4GeM9bmY6kJuZPuRmtBu5SQzGuklgY90kurEmWqkYa6J0irEmGqUYa6JAirEm2qEYa9L0irEmLa0Ya9KMirEmbaQYa9okqrGmAleNNRWnZqyJKGBjTSQyZKyJiAaNNRGayVgT6Q0aayLPQWNNJGwy1kTUg8aaCH/QWJPmMBlr2i6Dxpo2lNlYL+kZcGHXr+92AQO36mjBvy7dKRN6CFw5KlrnBXy6i53OaVFeUBBhdOpRU3K4RrmL4hmxHPPo7Tvyt3i33AjPqg/fDqKZdpV29SU/hCqvyAEqmkXpoRaU/xZKd0mXm+m4koqOSwZCwkQmxx1gI0/RyJgSVFWifBZAbgQlXsBEiTTu0Uw+dRkXmDdMwqrLfVZf7Pxk128F+phH0bMuaykehf/MMdHoHC0eQwwbNZwcL83ujS7knz92NWxTLkDrH3dR0CkAixMilaP8LAYhBIp9QBATL6cwErSQX3tdqAkCCSENwhhtol10BKvV3ao1V0yBMVVNA4NYCXfhMewqR+/vLuSfYsV4CohrhTahoVrsYnBPpUQIY5VkIFBl3Oh0bJmIs1O+EL4FxPQniAIhH8H1INeZzZXosk01ECEg2sExipDPabPr0gv5p4C7TYFwnU4IHQOwHvwetrkqEoSpNgqQgYld4HIm6G3vhfRLQM4TQER+aNIudofcXBkRwFQXGQbkwD06xy3ngFwuXog/BMzsN4glOkUnBNaDXn03V0PIN9VCAoHIoxCFp03XHuXnhfAttQX+CfbzTbgLYb0il/X72oFnm1uhgwD75svxeGylF4R1/AUtpF8CZp5wAUnR3B5uRQATvzIMwLFhYLSWZOgm9cXj94Tjvzwch7farZCCjjS/gG/94jv+FkCJXlCI1CDG8sQHszaGLxHekvVHmLSwn/JMCaoKgVSmWNr0RoCZO9PxfH/B/xPnOwLqCVMfGRtu59b90q3ht/7yhe5sUvwlqoo8q+IveD5rvnDWnpJu2A1VfmmrvaVKzk5jQ1zn1/ACXWHFSbjwJSYHBbsbrRArPxrFD9Rqu9kaa5X2XKP7J9cqjSbV6uXFNdYqOf9uapWcJ9XKdV9ejNVqkt9NtZqkp1oa+O+FbTPPy1NepiRKZJn3SJkd8g2DJPzo0fsx1neWVzRdOKvliqzuLbbIV2JzGGJxGEcB1awncbHvrpSDYXJRtI6CA/FF0BPLoim3lq5fWSio8ETXzq/1oot7qOVx/azCEqHMCrLI+liU6ITKyi5RdA1RZKc5OxWNfz7fZDkKTBCPsyzmPWk51BRBBsS20gNBqs3E7rePEWEb6UAO84j/0Cs/bUT1FR0gPDzcKMy2V3aLaw0F6Wa3+fMiCOP6jdxpEhHgys4t+1jh6UV4ELCFlPxriYIoz5K3T9C0lc5XOowsVqveYrQ2NIb0iMaTWSM3h2W2bBJ5y9hpqQObFJDjhdV5QXsy77LfWa7Qk7kLDQJR4rAMxDhwl77KBB6idD4GuRAB9Ju3QzSrFKDpDRL1YKrL3RamKrVNkQRxVqOmNhtVKWrGCg6bwZJVufeHNhpjU6jVBKLOMgaLxnJMVZKTk/NiFJzQCqYbUSq8OOy4y50LDzw0VY1qYGgm8KqiWqGbPN7ttiBdkghfmR2iSrzCgKH4lcd1/rSAcjGJT234EXnMke+n4hwanxQIJkWzAeUULmTzq78EdNoVO+2GHbn2wxGxW3Ptz747c9oNog4TiQQC3E6SKyRfP5LqRBDwMNwcTXCs8uRaS1fTSWMpVwZNmNoB5D/FLGp+lWvRWr4a40pGjhVKvW9MmmLoSQ5Hbh0eC0FDbvWIpaqDOg4PULgihnXlekC4reWXIIkj+4RQhG2SFF9CDlyi6B18o5zGbuRY6zzHfQVovDYW9W82Cfy09w8SZUOcFMmQiCy54yxLn0eCzLPWzsLdbBebl8Xy5Rm8dH5fhteqzlMe8D0m84VYmY8Iya8B+wxIRFap9B6GkSYmJF1xenAxw6ywcF0wQzxzmC0DpM4cm+1CLPZOagVhk0ktXJv/VFR0MQDHlM5QfR1bL1iLbFhcOubxZUxkdFkPUjEX4b1RDi2pT2FHygqGHVMTUnJGdYByvXXq7KTApmrUDRSFAcNQ8Kb0xR6asBh7QPulqPM2SoimYgYZMnXlslcZVbJhWUI49j0IVJnO4IGHLnmYly40rbb027pRtAsG2TPYrX7wAYsDsj/O8PQUnaMCe6JQ6P2aYRxCoDlW6xD52yF2ySD1fsyOQHfTBj+8ZsOzj8XYsZAEIzOoPcnr7Xdd6b2paP/EYhx5Hsx5PhcMg8xMG1usjxlDH+uBHehgOrfjepepXH/XAvhUNGt6KxsR6PrYo4Bx9r4rAxqjvcP7f97awPOchb+auDZg1dWnmW1G7yzRBCXN8hiQ0pW5wE0smVYJSvYY9sasFCRQkNXetYIgfHitwPD/p6a4wHpBgzWuGXqwDoKOWzv0UJhWbtQaYjy1/mJT1hIjZWiGH7+mmFc9Q9kJa4u27PTVhbHoTenHvXRNoh0AH73OmCrYvqITJ5tt+fkrjl4Uqpxn8TFtBjkKFbSRdQq84GUEi0YbOFxk0vpjsvEaKD5PNd5zJTIJJdRE642ziYZZfrfVyASEU9YjhvFWnq+qejxprmou3D+RGcvC+FXJII4p65LhPjgAP359Mrn39ZWdsk6BdW5O689bq6jKScYcZQOm2wQjAY3L/NUiG2HQe+1CeXEAE27U9ASFEgvLrwWbNn/+ca3q+PRm8+C6LBneXZLYovuFWhW7K5WjKjyGknreSHr5WLi4CT9KYUYI7LoroXnFktKUdyHn0TMnVCIdQ+bGnNkqQl3BvfDhrbl247Nncw7cmoNEwdtldAV60Rj2Ne/LY53BTa++4CS8/MEFJj1BQFQQfvXkqzzLqZ06E89PGA7CqZ4A4WyY6WSaMu5DZ9f+iSfbcGvpB9qOdcYX5viTnkAGX+TB+UsBVHmDZ9LJNIyqO6OFsbXPNvIDWMuNT7kj0dN5Nn0KqC37fFMeRghk1Pxpjra8RQBuDNxGX1BWV139+G2tm3h8S0gX6t9e7OK+ilG1Z5Vv8UlCaFGqb1jCh+PZy1HyPIgmSkT6JbjkVxxGl9jzEtUlf/1Rrg5/+LLOz+cEDfG/8cjD1TL/fnicwf8eaJkxteDlBusyr53bK3L9omDHGWVRtIH3RTzye14wNj/YeJudgs1f+8eNp2AT9bkjMVxT19ktXHe7cD2oropWd4jH6fUEYYzX7JFlAN0WqjVFu6m8lVqske/7xzm12IMtNU/DjTWa3fL01uTAXR5+1gPaShKwjNFwz93tVqqGu2iLVmsJl6TfDP1wHYVdDqWGqmYzlOP0erQAJmj1mBKQTvPqTNFoKl9V6OF2vXKm878HWmamNsN1mdfOcXbKB6RAXxpWpEASOxRjdNhd7dYvGxWRuw12xw6RqMAE8XCtvNXC3XgLd7eWq6XoLsE2TnHHVXm81g6DAypLqzBJX4ksVbadrbM9TWR7r7bCPE2FqjCzQdm96NvAgXH+CrYsA5ooIZIV1ogOOcHOcdRLnasX5DgSOlFtOYURFfX9hfuyWmy1eiq6y1Gq6vu4GMYr8agSgB63NYJV2VgFKmWlCuHmxVdEP1mhp1RE12lDdea1Nr0h39+r221gyPvbIRljgcOdt1qtFFTHyHP5gEZRicrMkI+oXed9lGunqDJDOM4Qj637eC0eUwBQYl6VKeaYClaVtueevGgy83u9SeapL1yRee1LrsYPm6Ld6eUUqKaIJApoxtpjD22QiiwKkIN8AZmowBT7iPqtdwtv/bLwfEepoaLAFOF4Szyu+uM1eAQ8oMCsJlNtMJGsNvxFL9FpKvN7rU3mKTBYkbntOxyQYbVeBWu1E9PEDsWoFdzK23ra5CzyXG/dIZItb/l5RL18b+HvFpu1XCnN6JafR5rccRWeYnCHwEFzi6swae5LJKlN2d3AjSayvVfbYK6h1aswqzn548CKp5Y7Q3uvTHaZcRqckbgZAPlPFVJj1HrQJ6vgFDVcJTfL4ajilxVfJaH2gRFShEUzvgNMKgn0Ba2C01zO05pncg+ZUzu9swzU8THN0FzS3N/6aNcRXbQasTGdZ9Dxq2GFus/DfmydCtyJzH7tERI1iWl6R5rv2QYqOqUzTW+u2d3pUY/3YE0f1hXZA85dvY92KdE7rJAaNcka8jgrOMHu9IjbXMVv6EgGN/oIKcKimdGJZjrStQpO6UBTm2d+93nIwT5Qx8c0Q3S4cz/zo71GdE2LdEZ55Yd83SJCqL884KWXUMNdBfTaj5AbIIzpnWSW316u1KQ1zJSmmN03HvDn91XtQRVQ/Pvcf/1ozxBd3gqpkR6nQU+6ghbqIg/tCKj44X5i2iEYIUhYOtN7y9wNAq2CE51UU1tods95bONgoJqPKYe8kcDd5o/2HtHTLlMaM7IMOu9llFDHeWT3QcEOdxvDbsQIAYJSmd5pZu5HqJWbMsxMbJfZ3eWhfYr+Cj6mEdK+BffPPzzSCC59idDYcWZon0BCCnWWh3Y6ZOxwZ4F3PkYIEJLK9K4yb+NDqdjUsWVSq8zuKo9siPRW8FF1EDdI+M7Aoz1F3EwQ6YwZUwZ3J0SE8Igyc1dFQmwaTIBdlhFSA0QxZyCZsc8iV2rKIDKpIR4YQmbvv/RVbZYCJHH2+aZe9Ji6jYCRyHruOP7muDqoNxCuWYRKXIExQTH7qMl74RlX/h56BpTifYfu/gAhoW6QZ3o3YL5T4z0EcmOJBN8+1hnDc769W8hKgUaVCjS62J7vEo4ToyQ3gnqC27Yw3wngYmQOEjOD3Jb6tX4r0A/Ha13n2acOeiFklqhCtSGvuh7TWMwUr+4tT0GExPsx7B4KvXqDaxuUs+JJK2h5HOkgQrTr4i763N56cUjQ2yQoKilbDG3SQsTZGbg/xtrEaUOT7y9xFKFMvLBEYazlyq/urTFYkK8EnWr6VdLnR/DntdAJ3TUrwq7B9lwGdDruxFtsS8/39ffEWCq/qPb0JL4utlyhlN7dajWPBbDk6VBM3DbuLvtNqYNF9OqhtKjfeCWVS3gtbIqya1+0GhbKkwetcR3HkePWnJI8qPcY7CA8q+kIMYVZ7+ci3C9ZOF3HctRo7fJ0TriFR/AncVWzEPR0WvJ49HbxLRLXN8W/kaRFG+7GQwkTAdE7mlTzLEW4WJTkoiWPhKuEF3KUi6tMPAC6/wK1dWZoq67qg2oLVXNIfUtqEnRhO4eyjUhMm8cocsqYKHAV6zvJfMgoQOLkGmaSLlRGkbTa1gbRjZQ4/u4TeGcw2Ou3xovBosQVrLLA30Wf5cGohyYLKDGpldurzo81s95p+tsbbli4XqMHgl8b+tpBirL6f/1AGfi06IPBaPohSPX6Qeq8+HQT+iyreWdUSbko/hJHqLwpDdCOLur0AX7ak76aIKCNa9Tz0JAyuXTp7DJMUFDuj3l90W6OG0cw/k4BcJF85FMcEst8wSQnSisTd+Pu3KO2MjENncwpIiFsV6oyGZoqLjBHEuEnl2Qi3fJDJjPrlIqkZ2Q2qgb/aCEuKIgEoy5FbudLliX4DIK+vJBZ1BtZqTMUBN+ga6JCCeughbAk4sagJyy9GLndEN1CxycstEgG+Q0QYdE6XIt2WQMiye0B5O+H8oWVMJTNnq2TudWJGmjBJATMt3YOLNTQwp/fKWLqErWmsrpPsJSQZW5mkCiQO4ABZsMIIz/rwN4jKBoqjDrPk2NQ9j7WoEbyINlVHZS1hMMcA0Vtq7isaju8xEmkjmoyJP2kfqgk4GWeQe3WoJi/Sh5Sn4UnnOkAzpcMynRNyezjTKhOH2simMgFrrqJCSlPWyjaVZHEtfICxtLfeNLDMHTGxVINONrgVOZJJgAITP4lqBFTUbkUm8ZJEzQHcCF9ByPgniVDtioo5QEdNgNnr11orrFemsl5JE2IpEaxHRVIR4viEoU8+ss1zaRgQV1XNMbbMRiIActxUz1ngOE2WqAfR1iyH0dYMhVGtmR4gogNmRqnqBfPoDFRxqZpVgW0Hf19egS3fQYGYneSpdENocgTrZ9GVEgWJxhaIC+whCV4SkmEqmPefDJgF2Exf7kJUGBjCn5DMUoKcK8RxxTuj8z35DzDnnVxJDTP7aDBVuzdVV2iOrxIXmwB849inLoFmMNDlUl5UkQ1w6TQZZNCTvuDHqXNxMl3w2xJYCCPEqDIcF89R1BWAPtoc9Ae6mJWH3EQbrBtZNLABM4kMSjCoTk4ornufFZt5JDtafEJ9moGS23hNVy4jaYm2+E+plTY2XO+IX5EQzvI0DvM/0zCHQomaC6pycoaqyFjSysxS9+lDTraolAB4o/L2Q6KAmWRJAO7KBFOlMQOlWITLaCoZViQ887gGdF9p+OUcsWMGjU1DKpC9WDVQftJiDUE0MrZI1GNYLcHVk3pt6Rt68pvFGpgVD4DuCRv0cDre2ocSLPvqtuPFxyYhgck2IOxowJjDrytDzyeDG+7qRIwzMj6wNgMTNyKkPHiZZlxZCa5emP9qKuNCbBfMdVSTGVG4G8hNS35p7wgKpHFq2mzCHHuKBGaAPtFqJYyi9AI2SvCr/r6qzQo6XUXhsQpq8jFJLxq7YemSAA6w1p4erHeph7ZzmMb+V0mEmMUe4ZWg3UQJymGVfpUJHDbT8Ro8i3MKdjXShMmXkpU6aHHetM4E7qq5lmjacDjB4npaVxpyHfhwvDzv3ziZrsH8YQV9ETCuLccRkQXMOB/56cX1IjKIE26K/NIlY6raGusEt9Q7H8yhd8In4Gi7wkNtvEMUjZGVe/cJL3k4ANcfEBnT0eTH+BON87gHYCov+6LEo82fJ0Q5/o9F4Q8tDHVnC4H37ni4vmNjh9srwLMJvsS81oG6HTYYrNiAYJMC3zng+U7H7rKsOkrHLpe6F89z7EZcUyxD8NG4SEqbNGu3iq4lsnHpyiogz35/X315fxdkyaH8BKUFap/uNan3eLD6qfqy9lq0iSrfvj2UtfF/vvvX19fl6+rZV6ev/ccx8Elv7W+xOj1X/Pmh2+xzdlZu28/rP78YfVTEdQX6xQnyQ/ffvBWp9PpWyv64dufN0t/s15u/cReLf0Xa7XcuB7WktUO/+3/1bHWS29jecuX7draLj3f2lne0n1Z/fbt9xQxpvph9een57FSwka9RmUaZ0E9ZN4ebZFRtP4L2mVtrcV2qeoy/4zklnEs77KeLWRumudqPhSHZiLlh9q5hz5Zxk6yFaKxgUu/q5V4gMQ/WRXttWWvBSMRxmWYIKv84dvVt7KxMOphX2W/ohLS0bLvdCI5siY7AOC1K/MQuUvmKep/OUR2AcHPnnQV+cpGxAeNO725RK2IZzl/JZbkt9SxsDlfXda66bbY+QRaczpsf78rGst1isZqx3qLzjOnOK7a+RFe6wVlkIVImB6picrvO7R1ojwdtnOO0el0GPeSievtFu7uxaBNFP9+j+doX4Lk2s6uWWODR+wVHL+m16SOiwR9Uh4l/RVPfT6RdR75/OHJffr0zN0r0uND0rkG8BKiyvjYw4HqxJsVJzVGTRFk0U1faVEgu0pH+YLYIV/5UEZ7fHereIi2/geVTnIe47abRsb1BDpkd2fwcOAUU2Jan3T7cn3bEpOI7B1gLTxiSxLuNVNe/RlPC3xSj5GE8GjLSJHtIRUW8CRBdv6Isucelto1zb+W+WuFnu4ASXgZxc/1O9otoCmDzKhBxXCVZ9p+gVEEQ9Vr90baHWhlucj4ZjWdV0W1HYa2SZjzaaDuWH8pD+xSlTBLyc7opp9lZwec+k+dv8sQRjhQn92Ccvd7Tq9KYuLvu1zT4zt4l2QamHeS8rXwV++MmLJM0Nv5tbMvmhRh+RmcHOK5N6bQA4FHhWtgVOsIHuF+5ld8Oc6oiqrWzbjrKtxLVW+8jpGvfkt2uBC/OzHouYRxlNcswwOHXZeBdB+Yt7B4aUDs0PKzc0ZvW9/tcVUBQGUV+5dB/37XyjbGvs3RtH5JDWqSUmCyFgnlf4+KU422WNq9O/WFUZrye9axr6BO1Wg9quYqUPXumjMmDgbPoFTljTiBtVOcJHaSv8qOJFBBB/SQYLoWRXftgO3i+UUzqPwQbsMj6MDxONnN889RxgeU7x0qxnQ0C770XhxSJq7qgSYlLADBR6O99N7sI43EQfkR1fZ337uyHGgJ+yAoQB0cK/k8vziX53tbHNIiX+Quqlw9ehZMBiN109ZGQK9Rt835bM9w9IGvo3RqoniUHCooed1L1zFW+y9c2x4Rzg2ao4uT3ADt6EFVWMrXWUesSOXeb7X/Et9YR0C+Ka9eN5lzowLjLuIk0RUBakMFsr0KKeTReEstrlGnBTA0NpOCzspn/bVDgrQMvVkUo0gpaB+DKsYVJz/OZf66dyEcdXDkt5J+JD+KQDh/QbumBMPaVbn+mwVfjkH5wHUKw8Pk5AikfUT1K0KZydgcg/LHJS4RxBkqF3qSfUqucdRrDqfywgnbxzIQThtLTj/Zxeh6sI/RlR507463DJwiNF99l1kTrEyXNmCIMSA8fmgX3mYMIwy70Ntkh7WjvZ4vFjIE2anqoI5DFjhHIiUd8zW3D9g4vqBiNg/JJPYvMmUTuxh0wJ8zQk4SllpsLc3JDJ0ZHRXPoHfc0m2ZwJSiJTx1hJ5w0N6AdOoD7UphOw7zrHcPbukLq5clEKCE7ZiBZ03kYyTf4zazyF/thhSfsX1Mg4ZNi/2tv3zZFc3zjTNLNzbIkVfN2ICZzOwMaHdHu4305G83IGGqeSQeR5m/WuxkeN8VcBWDJXZvpUeX+Wt/AWPn4x7goeKGDg8cD5R73lzJdzZesYw6f23nFm3ev8RpkZd1kNUHoc/Te/NGTLybS2MooGDbzRZWsDTqqaaUOVvBthuY8KMKlkYTFUwuMFnB1OIPKthkyQ8pmMDfgwomYBqrYC8vLqxgybmnmlLmbAV7efFAwo8qWHKeqGBygckKphZ/UMEmS35IwQT+HlQwAdNYBXPdlxdYw5qkp55S5mwNcz3HASk/qmJNMlHF5AKTVUwt/qCKTRb9kIoJ/D2oYgImWMVk+AcbclorPtKE79l+5sab2mkOAw37Tq3a36Q8M6HnwsRF6KInT1mOQBBiVDYx4OjLs4Go3Dh6QX9UwV7OZEgTh9tRhFQnnohh1YuBemg6B9QYZkU31hBodclf+wBB99eoJuIqBDWO7CWUQswOoKOry4fOwkrHJVf4/9+OOGUJHMxmfFvs/0v/+VuWR4e1H7712gS8Cg6D4odvCddtchrXqEziNK5/+NZlpzPX1vbieT+vLden/3qri+cBh21hOaGmntIhyH3gwKACNLO3mzCQET04CsrPBquhZyk0AQD1LQWYjtFQeL6/4P+J0jGX7mNpwFhIxLajqIEmQ8Lj9eIxGo4ekord6IGUzIYOZ3SawwwDpkJpHsBgSBCuQRS/V6uBmba6v/7LbIcsLMV0jOoiiv0A8vr6DWA92PnpoIxG7UBoTuxuVeEcXvMyorOmY4mCzzb+PTIoersxORQT3TMGRcd1+PGibJM7ahQ1ArUkvnVyrVe88GsJ6SyorRDS8bE9TI1ud9FcJ9vl9UVgkykDN49F2vYxj96UfTHuTXclwDquE6Ts+vJgfgSguh4lGHpwbwVG9+A4UVOLtYKhBje6W6jvuk8pUolcExZPt9004JdMPDAOienqC9E7Z/V8MG2eq/opUYdUiDUPOazMdjJsyy2aZwtIcixHQvidoC1jFbaV8CnPa7NExkpADmFtqD4lBahye1DYgaqrJ0m1p8cY5BA2yw3UoLYcbobeveWgynMWMgmyFd1PQ8LGSsfp2ca6mwRv4w94s/Um3BPj9CwebxrSHoGPOi+Akqrp0lEYzVgvNVobgCBktcxEAQtmJBsh4U0c8/AkQFt0kJOVxPWLpmcTqSMl+1OIN0WJo+QrETtJik5f43nv4i7+wTS8ame+VLMlmT9MktEkRmG8iFhcjJkyosR0IQHIxTrDw4AA/Z3EEL8oIFxHAMqYBu1JUVX6kFqitViMAeVdsuckzQgs1KKOJsh65cR66vZ6aqwTM8YhwWmQgNwmUzNKDaQGCm2IZp4lb+AYJ1lzuMSQTDTIAZlMmI720zHKDeRoWNmmzVZFglpcHjjulMDYM8D2DCxDkpiP0tjc81F2rfDuaAV1U3oBHUKqG78VQn/bYX7N6v3qoPxUoM5B0R7YAZLysrgEWbV3D69xlL9We1cmqgyohjujd7AQvLoJwjAvozjPLE1q+cmu3wokyo0n3Qxvo3WiGoHXGrlmALBJiEzMzIjgrdIRKz0v/HaJgigsr+lxzOnqdnGiT+1desRr6PE1+faiYmU6ZsjC6Ts14QZtNw0V6n+xCdrUkk8Zt0ewvn8aQYyslFuS8IpZKaMcLebnw4vgHGekmNwyyq6YJnJQskVwRmwXbyDOmXwmFVqvuUWj3GL1/KE3Ug03dfmZ75Y95RUV79D/gOooJVMiRXW05JjQ3shYCeplzA7ftCODpJzqH7CElgIn2P1Ti54RvCMnzrE6av2Tkz6TpVFgCi1i7y6Fjzg9rjQcP1Le4edCFSkMPkHLrxrR18NGH9wXOyI5VCJ0JdVjM+bg69KHMfZpgqntVwNNv+LtAlObqAgANR1AIleloLgmBUWFEc6RljfUUYzsz+o2g72Gjl5BdDYMTVI0ECkE81YNwTwu5LJyxPgYVAhjYUzQFwCV4w7HOrMYj/rAwW+pMATER6eeEtloh0Q2nVz4VTinE4VdlHEalG/SToiU8+ulRKdP7SNcQJb2xPzoh+c2XhhychUK8yySWQEK8eFaKQRxqWbO5dNf+8eN15K8hiGqqn4uvV2wXftKEZBHKWsuhy7aotWak4uzU97PnrsNvONOhId4E9JnM+Zug92RE3oNyizOzjf5PUZobAhdZ6uUgjiUsyQmxcceh/mMVi/IcTjFKMjOcnWBEuHK71qYloBYlHLmivEYee6qZY+chhgWIns7UigD8SdmPCLAADlIEEc5cG+NxgYT4WHhtemzNTDyXG99X/7jmh7zusyzdlz0DCsrw111eCVFxmCzY1inusZUyVgk8DTuQJ6+Ck5QCYV0GrXZ53YD5qSLP4QoWaR3XZldJuOZZKRWBlCeF8VVGldVfEyQUt+1gF6AspZhklemcLrddpKh0iCDyqDnOGtn5wNtHobI1+apx10U4FFSQmVdpGdQGOjLKYx0UFFKLQfe1vc4oDYUrnaraA3c4foGeWiFfHUivYl20VFDBrMY7sJjeNKBASY9x1t5mxZUHgdd3996a8gyrFHURUjiVFdoEx4VVDCDRzc6HTVQSIZHD7krDigOgk7orzfA5vY3kYvCk6u2L0I+Oop4YMaCYxRhkyfAQVxtvHDVcqWMgDt/s3YgoZ1Op1UYKYydTggdAwUVzNvphHaBq4IC7Pmr1clp2ZMHvq3nhmCTnnbRVmvSkx8KTUoxGZhzj85xq0ACvK1fXM/ddkZFGPV27s7deRBrCP9RWYtO0QlJiGDOUIjC00YGBBjb7PCfrgLdYOceXeRBHZX0yRe1F2zCXRiIeAxd4OV4PCIJDtK0teM7/v2P3MP8Gb2dyiBFlVWU+blEVWUfg9Ku6jIuUHU7lXl6g4JmuzRkWZ2DuY7l3O9//Iq4lxyj7IYTQ8+or4oLi1otWOUYP6hYhzGXluHnOA/q5GT6kzzMHyNE4yDTCWu5qWQumaQj/YAhXmEGpX3GVURZ/XHtR+i8AI4v+s+W539YCAO+9tt3PhhKmnO2Cg7l97MWhd3t7uJLNQyyOA1qFLX7KjSBaFFl0WpacXaKs7hGoBoeJpe4L8lMzvyqk3hbhICKR8ruwkmkx+++39VzTXZASotHTOToGPrD9iYcfJZtyJXm2iLy8S/WGzDLrnfj2oXH1lSwDD8aooVpGesa1w9w9ZxHHGopg3jVJ8tBmWrIhJf4VXyjw+0Sr46Kl7WF5vuf4SoWUJ+Sa3XRzuS1O3jt2S/h+Iq+sFHxzTmgCuKZc+AU6opjFxB8rWAoP7F7DpSSuq2RJb4mmYZc2TQz6QilqegITtTpjV/k8PWMEcNEMQ6WkwRpZIuvnKaiHyVKTlUSJU0EKI5civFVl6H8VDH2l5KEaGSJr+6mIR8lQk5TEiFN1OmNWi7ylSFUeKLw+orI/djEDF9+TsA8rhMzgnInJok6sfHrWbp0NZSfKLyBUpL8+lgiS+RpyEeJkNOUREgTdXpj19xseQ0XnyjA/kKS/MwMsVX8JNyjxMdJSuKjiTq5kW4B5gEAS08UXm8ZWfdM7HA/wxTU4zSPUZQ1jyRCLTXCccF9FFDhyVpnLiKPFiZmuCNkAuZxQwUjKA8VJPHO3M80MhiZv0pHDnz1vV59s7idCDl0xt+edMHLD4c+ZsIfU1j6jODE0y0jyvBmGQOqTCUdePnXMr3178drXecZ99UzX/xAQPs27q8hnPh9meZRkNh5gbKb4vQR8yz63YLYDfcMtSlvLPYABWzXkae4QdHAvZR2veb4juZ6EkLoU36iOEjyM7BSpct2chqGPaHBQjroR2cYruUpiJAl4xVcQ+TzlJeptVyx+LH5tT4MQiy4tA0ItGyKJwlq9NFZ2J7/4fnQkzcneq2pugvZNadHqaUFaThRSU79lXBMNXCe5Xa0qfcORYMPfQvvldJ3aRzng2VbH+m5vj9Y3rMJtXZgUnregiP7clGwCbHqOGKWMu8Sq/gohaySfSe4lCusXQDEgTus3rPedTCyqMyLud1zDU2THUfDTxRNfGBIycbqdBMNMs1nNylH+AZHhiF19Vt4wllN2WPdexYNPjsm820pplnY+N7bxAcr/i0YS/AurPYkfSvEPHoD9M9w51bgkt3KHOpmYPgelEWgUOU7mq1XUST4o34t4CZHrvc1Jn/ULg7clPj3YpkqLPMkOQalnaKguhofhrVfXl5eiob1Q98p2j0P8t0OPBRfz5kDyQ4KASkdp705t+ePzIntrFo8k0XjZUfZNNCKgRiqVGB2hZntCwxHyyRiBXe0zLLO86SOi56HnF1n64Ce471Dp3KnII2Ttz2ejyTIrt6qGqWLf03i7PPPQfgL+flveVYvnn5B5xxZ//0vT4t/z495nS+e/htKvqA6DgPrb+iKnhZ/KuMgWVRBVtkVKuPT4ulPGKn1EzZP1p/T/B/xU4dHT/jlLT3mydPi6W95nUul2DSUHUUv0yCR5qFrdR669MUdAqzd4m9quMBpnjhp7RK6AZSkJajGQwa2dLgbMoZINAQSCEFKUaGkvTGSRM9lkoLEZOjnVsFAC4JRZ2qgWPOXNsNaBmWZvwJqAr1KvNwJ718s6VEVGVHPu89iVNmBNxVocxKDdV8eK5vRsLEQfm3sIglClKKs/l8/1HnxaSGC1Hjk5Idg1uzdqUEUjHsVE5dO5wIfi6l7dQDE2N3VIKO6/JQE4ZrxftD3wclY3ssHMcCyWEhStyKxWOONQAOJhj1QSYXDZiAC862G7CYSAaUmEmvlpmyh6JJT5EcnBqMlSBtcFiG72DhNuRgiSIg0i0uR7dVMQAYKS0IqPMAr3wFjYVpEUSmnxkdLCre+LCecMlHTCBJIRjiDS4g3+UxFE2mAohNotYKTt+ZELQOFR+amoug47jjLyLMtfJQmYTcP4N2E3vMT4MzedJ4jL4j/wnRkUFs5bPTpQMsvnlX9f7OC/6NnBe+/doVOAXO1mzaxEN/VWgrHdLH9gNCy5zMXWrJx9iFTfWAuwij2zUU4CJ6LKPeLfW6o+tGItlDApsxHyHqCeUO+o0Fz/mDZ7vN4Aq0cxxcQLKfOGYQPmPXI9rQzfmw4fR9ODGNfN5OStNl/UGqaDG6dMwOYxNEbRn30hEkcB6KTOGlhPkKf9GmchE+axpk06iA0FfD+He37g62nzPXGqJ55eghVAsIJTh+NCjhODadyBc4mxCnpNFUclCMgkxt/sxecEQ+rozgj5lBsRiwEfxujj8CUWEYoTolnmjh1pjxG1Xpm1yB/EFbT9FuedXeaNrEawyxBy0ppSj9N04blCInkxlyO8JpitK5ZfHTnwTD66g+D9k9+feeDeTYix3djU3N11qA7rE9b/Geggt2iicOQRZPsPx2hH9q6SUQnr5u+rmWXF1djeptxOQZUAcIIrdYAqz6lt01jCXZECCvAaT1tSIK6OBhpoZ+Jy0/Sy+ROceuLstFOk4Rtfe3mGLSGIPres4FzxH/64w6uRocdXInh/5QuD90k76xE9AZXXzqETSIE5dcKJfruTZfHVvOmzW2yeajt03eF+49w02ed9S0fATff1cWNcQpCZH+Jq/gYJ3H9xjfke7J46QKVVYHIsRCMlvgjtCSFbztDTb1Q0ooSfVHSwPcNDXvym8qYAe3Rb6pZD8M+Ugvg6eJR6EyDD1ReScJ9BEKpJNEFQc8u///4CG/y4/T7H6trUeRlXVkfP2o42Lq3KFGFyi/IXkXPVl5aH/sAQEF/pZqtImpbweq1mfc7a0QIvcoG5rZfmLj7GeRJsr6KSN+vAquIsNkntjbfJDlT+/ULzu6RnP1PFt2cGqwiymaf6GxRdi16epxHtv7t/pxg+ezoyvyKskW0izIvUFm/7VmpftwjuhxUytQD+4txA8nr42q8jWmAHkhqBYTtzPdFr9h8kzhHyG6cnH6Xhvr/bZIcPTC0iPlz8QqHPLlvKO/OYU09siNP6/wP/fs+0sFYiO/2WCuYSQ6yGqpmLEkyxwUc6WLYiUcMYEkKwZp1TvlyypBNnhMxsDr4/K0nHCYi35Petu0j+tD7JsNvmVinOEl++PaDtzqdTt/KD6LsrJ341kn0w7c/+0vPt5zEXlv0j7v0bfyfR/+z2L82S/8NeKTELPzfWV295ZbU1V36uJ6WUD/yzdPXNvnTW9c4i+IwqPOyAnq7cu7SxfqjbqD6shEw9Hj4vjMP6/5BieL+QX/8G2DYSmLTcUOHHzfkR8q6TrDqYsiXagIhj3+T/o4rmNXkcF7RHORT94a3IrQ3bGC2Bxx1tijogfi+rfcKFxGPBZsoUy+KTri9OP2VaPNBzHBDuet8QUGuupu0EWsHj9bUsooTuy196XV2TzhzYIsF+4ae+5IOZjxu380Qz6976pCXqPNCBa7zQoejj46roDRVh2Z7DioXJBXgAVcHLiJkGcpBFWDpYonjub0IbbowLoAHAjwbeqUkOlSzeyQaqJ5OB2hTWEGFz+62sSmkoMppW0LktUtUuVXBoRwTxzTAoMoxu9RrCi6o8UvhJW5ZksarBKqnm/ikYQYVPsnNWVOIQZVJDCxySH6r7AlASqKRMRJmUGGM3001xRdUeWPwIns8SeVQBtXTTXzSMIMKn+wCqCnEoMomBRe5ZCkqkxKglmxikYYaVFiklyxN0T5UDgm0yCBNUPkTwdRUowBJmEFNgOVnAJaGGNTFV36WhVd+BkTXAimJRg0kYQZVDbzEtWGwUyCF0zc6vJApFSP7BTdTlG8dVHkyY1QR6oeQoneMKQY9hTGqINkNFKODjCnkcCE4cKVbABoXxFTNDozNeY0V6yD5KthQlQ6QzqYAsHYEBSKrAODCQCYV0AaxtgAfRyRwbQzh4NScyxdhVVPOYVsLq4SpU6wrB+eGTg5WqBq5Vnyi5pnsTYe6/KzAat2/5Zr2SoVnSdak9yH4JRsAbvgtGuE57P7A7xB2qQ8OlhsOHQ/RGPt2jZFOX507MmL3HiupSQTCuAwTpDSc73yAYB31XRERKExQUJ7ihi+WlFOUOBfPvS/Smiey8UJV2okVcUY2XUQpvhoIhK6zQKeODC7DAQB1cEw6iuQXAGCX+asMhFMgwBAliQKJk2RQvAA3vAcv1FGCEtIEYPM1t8iu0iFxV+kYibdQo4VepcNyr9Jh0XOYMdJvYUc1QJUOtUFX6xHNALTDdrNj7ZAOqn06SvPTycqfjtD/dEQXSCf0gnRSR0gH+0I6pTv03IiM7OQ81A7JeUw7tFCj2yE5D7dDch5uBw4zph1a2FHtkJyH2qGr9bx2cMnNFtIQTTLUEE0ypiFaqNEN0STDDdEkww3BYcY0RAs7qiGaZKghulpPaIiijLMay558DImfAo1oARFwdCPQQoPtQMEGm0IAG9MaIvioBqEFBtpEksOYZlmi9Iinrqgq8qyKv0DvmYAHUEn8iTZ8jHaYTEVrCJ4hTsrUIpaWQvYrFzogSQDSYxL7GMjIj/9AYQ1kfIkjlA9vpUoXSmXvevug8N7Rq2R77vHtpdtREFzfa2+587fu2tttPgAF3Y2poL9Zej5UZH18W4EltiC4e3xzQXDyMuGSBHDAeq1EJVEUm+TSSCUqJE3VgMv81S7RF1SS4E0qbp5loGEqKedqhV/LgL0A3D7lp8HQ4M8CFE0AcclstDiN9E9xksjv22sgZ1x559Z+y6ueDsQVQFwNpLqUcfaZ46G/AEwMzJXAJGzKViGNn3IDo3yQrL6yKIvgkiiL+srR7R6tKE3uK8gCumglpXAvfQgCshQ1lKeZ+g4NOVzBBAXHnzGVwQLSSiAzDSYY/UyHqUC7VSYWMe+T8ZqUqA4vUhmWpheR9URK6xWAqCNAKVAIin7IxUyCUHVDLmXUDLkw0wuorEkrOsGI0mzLmuRZoeREzuTf7LSyz2UcEcNJ9/xkA3LoSuxV0yIgE1uGwPY1CynRtUkHDzYIgWatAbCrNonIsKm5CEpFbUkBs9ayWlIxA2xoshb5ABqCRBaknjEaZBB/6gDUCyiEIdRByKyXQqhzXj71wA1Rx2E3FaG/QVA+UdOnbiA4n9To0xwQnMT2UkJ9GTiOw89CUCl+Ao6mC2IW6iTn3JcEO42Q0hdbTAsMsHJ4WR4DQy4+HJRs5UiHGA21oAcXlQo8P9+W9EvmXC6qVptVqePAc+73ZVXaeZa8AVNQNtnsDse4QnwGPeAhuSqPp0Psgo/zDD5t0U5VGWGb7KbhJQh7A2AB5NAHYhXVFAMnMg7Jd8sYueiRIMoZPfCjRQ64L2mkArtKb9Jjs0uXRaCg/4g3l5yt/yzqEC2jFG+fZ5ZfEIBK2slZLkyKrbSyIFnat4Xiagd/tT2fPQ3h+R/kHN+58RhgSs6Wl9mqZVzHEV6akPPIeNE1i5h5wWzwo4Yyzgvmow1ppmRt21JbtRTmRFgGyZmEFUEtxNyU1qKL5aEWTy8tgIFAajs3Ho9BSq9tZ7FM39psfWcxLQlI04EAu4rpUcUDbSimiYpK301MbZdzqu+OpLXtEjKudGVZhysJXNPBiRHtFMYVjDzOgw6aqEiFyHpyFbybGBpVqYFH6HnapWulAh6h5QFXShX+FXxinAqFfQVlF39A5n7FuXd15leE2EpkXoMqCVTTQZXtnVSFdQWb8KKfwrmCkO6oa4yvW8Yhua8JsbXEOiT4NaG1VpiHJK9g5OxDoleQ0goAsvd5FVZ6BXxCzhcroEGVBKrpoNi5UJ15BRtjXgNMVIT0XKkCVthOFzBKyiAGpnjr8nULUxALUzQCDGBiiqOGCbIxRaIh041MYbvKs9IKzy6h5Eo8A4DEzBSNAGiyM8VRw2k0NEWioTVYmsL25DuxSjU8QtKTqwHUwiPkPLUWQCVUjCZrUyQaUtjcFPZKiuWq1GBF6K1kh5tegRWhtVIqoAEeNXwGk1MkGkrQ5hT2uuMeaoE1obeW+YeaYE3IrdUaQG2g4jTanSLR0BoMT2H7bT20vk0sT/HWgYCmpyCmp2gEMNj2FEcNn8H4FImGErQ+KZ0+McupTZ9qkk3MnQBHKqHBlhy2kWBLeGJ2hDGz6mjgCYyc1EkFJueU0zzLyfT/JgZu++Xffs6z3P53dL4mQbn4GWVJvvg5z4IwX/yUZ1WeBNXi6a/xEdEbPhYGf1o8/ZRfyxiV1t/Q69OiRc1IMd/dTTg+zpI0rpjnV18uaZB1ec3CoEZq0Ht6SL1NREkSF1VcASswhoh4FZT4bho16lkQoDT3AsljjhftnLwAaD6tQZ1A6VhPf5VOc/ZTzHP8/S2lmS7/Kh3l9SdnVcY5/hnGqb7/Kh3j/q/SMTsAHGpgEyAdvQ+QztkKSB/aDajS2RsCWCfm7glU6ePbAlX60M5AOmtzgMlryv5AJ6fxWwRYPrN2CdKZGwXp7L0CSSLjtwtUqYzdMRA0Z9amQac1s/YNVPmO2zqo0nfePUhnbCBIDTVmD6FrovfcRtBVe9ROQvr+mwlVOryfUKVjthT4GUt4VyHF+UYPGc4jczwBCPSTMcBGAoS9ZSBOg88MRAt5zqoh5xkG4FSHXWgMupGgexxpIPY+dxpIwOhUqwb8ajifkx/0rjHgRgI2+9hA3D2eNhC9yd9W9bvccDanPeR4Y7CNBGt0v4GYzU44ELnBFVcNeeMwAKc97JNj0I0E3eOZA7H3+edAAkYvXdXvqMPZnPqQu47BNhKs0WkHYja77kDkBgceMS4mHx41QcWbBAV68hhkI0PC/jwYq8GrByOGfHvEmvS696jhKd4kULOTj4E3MniPqw/G3+fwg0kY3X7ErPR5/qgBKt4kSKP/j0E3MrTZCwhj7/EFwgRMHkFiX3qcgtQQFW8SoMk1yIAbGdjoIIRxm92EMHqDs5AYl15/IbVDxZsEavYaMvBGBu/xHcL4+zyIMAmjH5FYmh5XIjVJxZsEaHIoMuBGBja6FWHcZucijN7gYqwGvYwMgtvnEb7GrkSjljB6HHuomP2OPYTM3kc++x7yu7Uz8EHXW7de6fO+9VzSIeuhNBrrfkujae43inmO+62lNNP9lkaj3G/kitI49xvDONX9lkZj3G9pNMb9xqH63W9pNNb91kFOcL/hQg+439JotvsN68Rc91saPe5+S6NH3G+t3Ka535i8prjfOjmNd79h+cxxv5FazXC/KdKY4n6TJDLe/aZKZaz7TdCcWe63TmvmuN80+Y5zv2Gi7+l+U5prnPtNaqgx7reuid7T/aar9hj3myD4d3O/pdGw+y2Nxrjf+NVak/stjczuN5xHZjsCEOh+Y4CNBAi730CcBvcbiBZyv6XRgPsNA3Cqw+43Bt1I0D3uNxB7n/sNJGB0v6VRv/sN53Pyg+43BtxIwGb3G4i7x/0Goje539Ko1/2GszntIfcbg20kWKP7DcRsdr+ByA3utzQacL9hAE572P3GoBsJusf9BmLvc7+BBIzutzTqdb/hbE59yP3GYBsJ1uh+AzGb3W8gcoP7jRgXk/uNmqDiTYIC3W8MspEhYfcbjNXgfoMRQ+43Yk163W/U8BRvEqjZ/cbAGxm8x/0G4+9zv8EkjO43Ylb63G/UABVvEqTR/cagGxna7H6Dsfe432ACJvcbsS897jdqiIo3CdDkfmPAjQxsdL/BuM3uNxi9wf1GjEuv+43aoeJNAjW73xh4I4P3uN9g/H3uN5iE0f1GLE2P+42apOJNAjS53xhwIwMb3W8wbrP7DUZvcL/xFYLZ/cYguH0e4X7rSjRqCaP7rYeK2f3WQ6jn8F80zv3WzsAH3W/demWi+43HZiHroeQ81v2WnKe53yjmOe63ltJM91tyHuV+I5FpxrnfGMap7rfkPMb9lpzHuN84VL/7LTmPdb91kBPcb7jQA+635Dzb/YZ1Yq77LTk/7n5Lzo+431q5TXO/MXlNcb91chrvfsPymeN+I7Wa4X5TpDHF/SZJZLz7TZXKWPeboDmz3G+d1sxxv2nyHed+w0Tf0/2mNNc495vUUGPcb10Tvaf7TVftMe43QfDvd5X+POx+S85j3G88oprJ/Zacze43nEdmOwIQ6H5jgI0ECLvfQJwG9xuIFnK/JecB9xsG4FSH3W8MupGge9xvIPY+9xtIwOh+S8797jecz8kPut8YcCMBm91vIO4e9xuI3uR+S8697jeczWkPud8YbCPBGt1vIGaz+w1EbnC/JecB9xsG4LSH3W8MupGge9xvIPY+9xtIwOh+S8697jeczakPud8YbCPBGt1vIGaz+w1EbnC/EeNicr9RE1S8SVCg+41BNjIk7H6DsRrcbzBiyP1GrEmv+40anuJNAjW73xh4I4P3uN9g/H3uN5iE0f1GzEqf+40aoOJNgjS63xh0I0Ob3W8w9h73G0zA5H4j9qXH/UYNUfEmAZrcbwy4kYGN7jcYt9n9BqM3uN+Icel1v1E7VLxJoGb3GwNvZPAe9xuMv8/9BpMwut+Ipelxv1GTVLxJgCb3GwNuZGCj+w3GbXa/wegN7je+QjC73xgEt88j3G9diUYtYXS/9VAxu996CJndb3z2PeR+a2fgg+63br0y0f3WhuQlC6ImGet/a5Jp/jeKeY7/raU00//WJKP8byQg8Tj/G8M41f/WJGP8b00yxv/Gofr9b00y1v/WQU7wv+FCD/jfmmS2/w3rxFz/W5M87n9rkkf8b63cpvnfmLym+N86OY33v2H5zPG/kVrN8L8p0pjif5MkMt7/pkplrP9N0JxZ/rdOa+b43zT5jvO/Ncn7+t+U5hrnf5Maaoz/rWui9/S/6ao9xv8mCP7d/G9NMux/w0PmsP+NB9I3+d+axOx/axLmKxOAQP9bw6OriYCw/w3EafC/gWgh/1uTDPjfmoR5yARIs/+t4eHWROge/xuIvc//BhIw+t+apN//1iTMRyYAGv1vDY/FJgKb/W8g7h7/G4je5H9rkl7/W5MwL5kAZ/K/NTxQmwhr9L+BmM3+NxC5wf/WJAP+tyZhHjIB0ux/a3j8NhG6x/8GYu/zv4EEjP63Jun1vzUJ85IJcCb/W8PDu4mwRv8biNnsfwORG/xvxLiY/G/UBBVvEhTof2t49DcJEva/wVgN/jcYMeR/I9ak1/9GDU/xJoGa/W8NDwcngff432D8ff43mITR/0bMSp//jRqg4k2CNPrfGh4rToI2+99g7D3+N5iAyf9G7EuP/40aouJNAjT53xoeSE4CNvrfYNxm/xuM3uB/I8al1/9G7VDxJoGa/W8Njy8ngff432D8ff43mITR/0YsTY//jZqk4k0CNPnfGh5+TgI2+t9g3Gb/G4ze4H/jKwSz/61JOs+YDG3yvzVCPDqlhNH/1kPF7H/rIWT2v/HZ95D/rZ2BD/rfuvVKr/+NOevyV1SGQYVuLJJdkFWnvEz3bYaG/1oUcJE2QysSBkVcB0n8m1amy5GWE3lW268kxjN7WFRI2a/kN5lFYBo+XIJem6GPeRJJsFsAlrAXUrCqfkvQnqZolaQPlcIvlBIA/nSs+cV1Eax99VhKpA8aG59Op9eP2zdnzS+my4AyLfUFdOOz5xSaPVhrfu1cBFMoSS+YG58tJ7DkpVvza+UtjExBeIfc+Pg4bT32OK75zXERTCYivyNufDycwLJXdc1vhgtQMhXpJXDj89+0V5M+Y371uwOSSYiveRuf8GbMlJ9v5pe7Wxi1Cu2b3MaHuAngMY9a7fVcz/deNJD0WqPIqOEMTRKEn23fYWBi3H45an/XgRVoz/cX/D+ozCWOaNTSvfO9YwUH7QlwGgNUeAXg0PdguPASA3sn4Ub+jZO4fuNPJ4hMxBkAR6OPCmDSq3t/WLBHchftO18qj4IHyfyGQbDP8vrj8lhnzxRBhMKchmLdX7MIlUmcoXtwPJa/1nGdoE/8bd72tTfr45MV1HX5keQ/W0/PT/eiRFLI1aJEtrLzQd6M+9/XvEYLDK2/qB5ER/8YHYrgjOxjiYLPdpxVcYT2wZc8ju71BQWR8tAeTkKljduluMfpeVGXN1P5i7e4rBbFLS+LS5BV+9XhNY7y12q/olliQVJjVu6POP1Wxb+hfbC6L7EYgjhD5YJou3IMXWzkLPhyDErpgcT78hhEZ6jyjuPcl/SZwu7R7CQoKrTnH5IWY0irjhb86zL8Aj4VGcWOoq6wkHQZ9dA9LSXYkji7oDKWcqwai+c78vdCSo/knxflJwoEPtr3ywkPvNpLAsULyDwcwIL35flqp3FZ5qXxMZyD7uJs33d5eXkRTNkhL4IQ99jl7mCnlX2KE6wuT0WZn+No////H39JgzP6Dz5bWv4ch2Ve5ad6+aekuAQf/y9a/Ied8/x0YIUDkpN3OYcij/Hkz0ZfUFZXTH3OV2q7yMzUxmzJOne+2tesQgkKqS7xV2yuFXnVHqerpsJO89/686u+bHMW4YZYybi+tSLzHhKZZxSZ5zzfibJd6jSRIlL/e37M63xRBVllV6iMT/eL286O/I23dQ5SAOv4nMWfAwGeZhML4KK01RPLsVZFczBNp+9Lap2ANzm7Z4Oc+zLJz/ltgIEE1VgVsG0la8eiOeTXGlvqvdPDAEb997/HWLStA9/yi8ZyLOegs4VXYrZfNMR0xWcyJrQPxjhFc+iVqiCl5RalPWx12P/+97hGqdIY+mucbEmt2qQD9Eps+6qSty0ay8NsMx3Ede2MpLX0qwUhjL8OX1BZx2GQsIVXGkdRArDKpkEdmv03Jw//OXCbG2xexPnjQR1jaT+G8VrVl/PtFCcJx6MDEhB28GItPCe1luuJkeB6USXEM2SAZenpf0G80kNJnv8sajwRaOumIbrU0vj736vrsb/riUqyE/pSZ1L9+zK8JHElbVrxNIuNn+L63C8aU+vxQvhvOkmwBWGz7L//PbwEWYYSO7umx26Ou0ZhFK7vOlSQIuHRpoP+9G8nH4epIICF0hKCSPlCawqqX/LnwkyNA9AXm+Dpl0tQIus/UHhhofbb4PpqY2iOB1Gj2q6i1yUgp2gqoTKug9UE4Ky3oVSMZp0VbYGszGUQxddq7wnkJesguZC2gi57uKmwOpvMhdfZC88sBchAvOA/B0mtxFHSgCgJqtoOL3ESKdulphLWMg1qVMZBYschbg9h2Fp6KDWVs+0IJahG8hIPOevVeiXyqfSiG5GqqLHtDkmPxe0WJkSM1tL1q0U7SlAp80mLnKwxYBa19ADcumjwOG3ZuHWl3vN80CjtqzBI0Ed36Tir5wOcrDNyisu2rZge1nlBzBNXSOcgZJCGbHN0fELTSzYaxsjyVKTiSqMrMzDR6LaGXlBqLVcr/Lfr9w7nhFDrJpOagw1ixzq76f1z9KSrM04w/bpP9fm6AJ7ueNg2H+sMYN+WOqyyruCDg1BUU0cOuzmdPLQDERykmc99meZRkPBjObrIOABZeA/NGc0CI0japUGQxSmdmpAOecrL16CMKqtGVX3ozRSaWuxX4qBEjS4f3NsaRnGQ5GcTC9gmyKRclREIRO/M5CsJavR/f7R9p2jEHq3ndVz+kaP6jN7IK/SUxM35cOuAsMlrf7r3+x8nAcMU3L5S/RV0DJVznjXWvhKVJDii5NY36oq7oO/W/fFv0mXKPFHNnZzLnj6VOyK1UfKQgf8svfbNUM93Fq7jM92+L7MzW/Ba3afd+oV0HrKzHZV5EeWvmV0EGUqEYuzF2z5TfugZA+5L5ia4hdeyyss9+8l9SbLgfcfpjEh1yV9vcj/VbBepvrt2Fvy/5eb5/v8EAAD//+7UkgoFGgIA\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/api/guide_source.go b/api/guide_source.go index 7910f80..feec59a 100644 --- a/api/guide_source.go +++ b/api/guide_source.go @@ -3,9 +3,11 @@ package api import ( "fmt" "net/http" + "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/models" ) @@ -98,3 +100,90 @@ func getAllProgrammes(cc *context.CContext, c *gin.Context) { } c.JSON(http.StatusOK, programmes) } + +func getLineupCoverage(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + coverage, coverageErr := provider.LineupCoverage() + if coverageErr != nil { + c.AbortWithError(http.StatusInternalServerError, coverageErr) + return + } + c.JSON(http.StatusOK, coverage) +} + +func getAvailableLineups(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + countryCode := c.Query("countryCode") + postalCode := c.Query("postalCode") + lineups, lineupsErr := provider.AvailableLineups(countryCode, postalCode) + if lineupsErr != nil { + c.AbortWithError(http.StatusInternalServerError, lineupsErr) + return + } + c.JSON(http.StatusOK, lineups) +} + +func previewLineupChannels(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + lineupId := c.Param("lineupId") + channels, channelsErr := provider.PreviewLineupChannels(lineupId) + if channelsErr != nil { + c.AbortWithError(http.StatusInternalServerError, channelsErr) + return + } + c.JSON(http.StatusOK, channels) +} + +func subscribeToLineup(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + lineupId := c.Param("lineupId") + if subscribeErr := provider.SubscribeToLineup(lineupId); subscribeErr != nil { + c.AbortWithError(http.StatusInternalServerError, subscribeErr) + return + } + c.JSON(http.StatusOK, gin.H{"status": "okay"}) +} + +func unsubscribeFromLineup(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + lineupId := c.Param("lineupId") + if unsubscribeErr := provider.UnsubscribeFromLineup(lineupId); unsubscribeErr != nil { + c.AbortWithError(http.StatusInternalServerError, unsubscribeErr) + return + } + c.JSON(http.StatusOK, gin.H{"status": "okay"}) +} + +func guideSourceRoute(cc *context.CContext, originalFunc func(*models.GuideSource, *context.CContext, *gin.Context)) gin.HandlerFunc { + return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { + guideSourceID, guideSourceIDErr := strconv.Atoi(c.Param("guideSourceId")) + if guideSourceIDErr != nil { + c.AbortWithError(http.StatusBadRequest, guideSourceIDErr) + return + } + guideSource, guideSourceErr := cc.API.GuideSource.GetGuideSourceByID(guideSourceID) + if guideSourceErr != nil { + c.AbortWithError(http.StatusInternalServerError, guideSourceErr) + return + } + originalFunc(guideSource, cc, c) + }) +} + +func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideproviders.GuideProvider, *context.CContext, *gin.Context)) gin.HandlerFunc { + return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { + guideSourceID, guideSourceIDErr := strconv.Atoi(c.Param("guideSourceId")) + if guideSourceIDErr != nil { + c.AbortWithError(http.StatusBadRequest, guideSourceIDErr) + return + } + + provider, ok := cc.GuideSourceProviders[guideSourceID] + if !ok { + c.AbortWithError(http.StatusNotFound, fmt.Errorf("%d is not a valid guide source provider", guideSourceID)) + return + } + + if !provider.SupportsLineups() { + c.AbortWithError(http.StatusBadRequest, fmt.Errorf("Provider %s does not support lineups", guideSourceID)) + return + } + + originalFunc(provider, cc, c) + }) +} diff --git a/api/lineup_channel.go b/api/lineup_channel.go index f08a3c3..fc63f0d 100644 --- a/api/lineup_channel.go +++ b/api/lineup_channel.go @@ -4,6 +4,7 @@ import ( "net/http" "github.com/gin-gonic/gin" + "github.com/tellytv/telly/commands" "github.com/tellytv/telly/context" "github.com/tellytv/telly/models" ) @@ -30,6 +31,7 @@ func addLineupChannel(lineup *models.Lineup, cc *context.CContext, c *gin.Contex func updateLineupChannels(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { newChannels := make([]models.LineupChannel, 0) + guideSources := make(map[int]*models.GuideSource) if c.BindJSON(&newChannels) == nil { for idx, channel := range newChannels { channel.LineupID = lineup.ID @@ -42,13 +44,35 @@ func updateLineupChannels(lineup *models.Lineup, cc *context.CContext, c *gin.Co return } newChannel.Fill(cc.API) + guideSources[newChannel.GuideChannel.GuideSource.ID] = newChannel.GuideChannel.GuideSource newChannels[idx] = *newChannel } lineup.Channels = newChannels + // Update guide data for every provider with a new channel in the background + for _, source := range guideSources { + go commands.StartFireGuideUpdates(cc, source) + } + + // Finally, restart the tuner RestartTuner(cc, lineup) c.JSON(http.StatusOK, lineup) } } + +func refreshLineup(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { + guideSources := make(map[int]*models.GuideSource) + + for _, channel := range lineup.Channels { + guideSources[channel.GuideChannel.GuideSource.ID] = channel.GuideChannel.GuideSource + } + + // Update guide data for every provider with a new channel in the background + for _, source := range guideSources { + go commands.StartFireGuideUpdates(cc, source) + } + + c.JSON(http.StatusOK, gin.H{"status": "okay", "message": "Beginning refresh of lineup data"}) +} diff --git a/api/main.go b/api/main.go index e1ebcaa..b6110db 100644 --- a/api/main.go +++ b/api/main.go @@ -49,6 +49,7 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/lineups/:lineupId", lineupRoute(cc, getLineup)) apiGroup.PUT("/lineups/:lineupId/channels", lineupRoute(cc, updateLineupChannels)) apiGroup.POST("/lineups/:lineupId/channels", lineupRoute(cc, addLineupChannel)) + apiGroup.PUT("/lineups/:lineupId/refresh", lineupRoute(cc, refreshLineup)) apiGroup.GET("/lineup/scan", scanM3U) apiGroup.GET("/guide_sources", wrapContext(cc, getGuideSources)) @@ -56,6 +57,12 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/guide_sources/channels", wrapContext(cc, getAllChannels)) apiGroup.GET("/guide_sources/programmes", wrapContext(cc, getAllProgrammes)) + apiGroup.GET("/guide_source/:guideSourceId/coverage", guideSourceLineupRoute(cc, getLineupCoverage)) + apiGroup.GET("/guide_source/:guideSourceId/lineups", guideSourceLineupRoute(cc, getAvailableLineups)) + apiGroup.PUT("/guide_source/:guideSourceId/lineups/:lineupId", guideSourceLineupRoute(cc, subscribeToLineup)) + apiGroup.DELETE("/guide_source/:guideSourceId/lineups/:lineupId", guideSourceLineupRoute(cc, unsubscribeFromLineup)) + apiGroup.GET("/guide_source/:guideSourceId/lineups/:lineupId/channels", guideSourceLineupRoute(cc, previewLineupChannels)) + apiGroup.GET("/video_sources", wrapContext(cc, getVideoSources)) apiGroup.POST("/video_sources", wrapContext(cc, addVideoSource)) apiGroup.GET("/video_sources/tracks", wrapContext(cc, getAllTracks)) diff --git a/commands/guide_updates.go b/commands/guide_updates.go index 3f2ead4..2e9ea77 100644 --- a/commands/guide_updates.go +++ b/commands/guide_updates.go @@ -79,23 +79,23 @@ func fireGuideUpdates(cc *context.CContext, provider *models.GuideSource) error } // Get all programmes in DB to pass into the Schedule function. - programmes, programmesErr := cc.API.GuideSourceProgramme.GetProgrammesForActiveChannels() - if programmesErr != nil { - return fmt.Errorf("error getting all programmes in database: %s", programmesErr) + existingProgrammes, existingProgrammesErr := cc.API.GuideSourceProgramme.GetProgrammesForActiveChannels() + if existingProgrammesErr != nil { + return fmt.Errorf("error getting all programmes in database: %s", existingProgrammesErr) } - containers := make([]guideproviders.ProgrammeContainer, 0) - for _, programme := range programmes { - containers = append(containers, guideproviders.ProgrammeContainer{ + programmeContainers := make([]guideproviders.ProgrammeContainer, 0) + for _, programme := range existingProgrammes { + programmeContainers = append(programmeContainers, guideproviders.ProgrammeContainer{ Programme: *programme.XMLTV, ProviderData: programme.ProviderData, }) } log.Infof("Beginning import of guide data from provider %d, getting %d channels: %s", provider.ID, len(channelsToGet), strings.Join(channelIDs, ", ")) - channelProviderData, schedule, scheduleErr := cc.GuideSourceProviders[provider.ID].Schedule(existingChannels, containers) + channelProviderData, newProgrammes, scheduleErr := cc.GuideSourceProviders[provider.ID].Schedule(14, existingChannels, programmeContainers) if scheduleErr != nil { - return fmt.Errorf("error when updating schedule for provider %s: %s", provider.ID, scheduleErr) + return fmt.Errorf("error when updating schedule for provider %d: %s", provider.ID, scheduleErr) } for channelID, providerData := range channelProviderData { @@ -109,14 +109,14 @@ func fireGuideUpdates(cc *context.CContext, provider *models.GuideSource) error } } - for _, programme := range schedule { + for _, programme := range newProgrammes { _, programmeErr := cc.API.GuideSourceProgramme.InsertGuideSourceProgramme(provider.ID, programme.Programme, programme.ProviderData) if programmeErr != nil { - return fmt.Errorf("error while inserting programmes: %s", programmeErr) + return fmt.Errorf("error while inserting new programmes: %s", programmeErr) } } - log.Infof("Completed import of %d programs", len(schedule)) + log.Infof("Completed import of %d programs", len(newProgrammes)) return nil } diff --git a/commands/video_updates.go b/commands/video_updates.go index f8034e3..73fa21e 100644 --- a/commands/video_updates.go +++ b/commands/video_updates.go @@ -4,6 +4,7 @@ import ( "fmt" "github.com/tellytv/telly/context" + "github.com/tellytv/telly/models" ) // FireVideoUpdatesCommand Command to fire one off video source updates @@ -23,7 +24,7 @@ func fireVideoUpdates(cc *context.CContext) error { } // StartFireVideoUpdates Scheduler triggered function to update video sources -func StartFireVideoUpdates(cc *context.CContext, providerID int) { +func StartFireVideoUpdates(cc *context.CContext, provider *models.VideoSource) { err := fireVideoUpdates(cc) if err != nil { panic(fmt.Errorf("could not complete video updates: %s", err.Error())) diff --git a/context/context.go b/context/context.go index 10d903c..01e61b2 100644 --- a/context/context.go +++ b/context/context.go @@ -108,21 +108,22 @@ func NewCContext() (*CContext, error) { guideSourceProvidersMap[guideSource.ID] = provider } - videoSources, videoSourcesErr := api.VideoSource.GetAllVideoSources(false) - if videoSourcesErr != nil { - log.WithError(videoSourcesErr).Panicln("error initializing video sources") - } + // videoSources, videoSourcesErr := api.VideoSource.GetAllVideoSources(false) + // if videoSourcesErr != nil { + // log.WithError(videoSourcesErr).Panicln("error initializing video sources") + // } videoSourceProvidersMap := make(map[int]videoproviders.VideoProvider) - for _, videoSource := range videoSources { - providerCfg := videoSource.ProviderConfiguration() - provider, providerErr := providerCfg.GetProvider() - if providerErr != nil { - log.WithError(providerErr).Panicln("error initializing provider") - } - videoSourceProvidersMap[videoSource.ID] = provider - } + // for _, videoSource := range videoSources { + // log.Infof("Initializing video source %s (%s)", videoSource.Name, videoSource.Provider) + // providerCfg := videoSource.ProviderConfiguration() + // provider, providerErr := providerCfg.GetProvider() + // if providerErr != nil { + // log.WithError(providerErr).Panicln("error initializing provider") + // } + // videoSourceProvidersMap[videoSource.ID] = provider + // } context := &CContext{ API: api, diff --git a/frontend b/frontend index 27ecc8b..461f7d1 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 27ecc8b47b68f9b6dd4d8886817b3fb1ff2960b0 +Subproject commit 461f7d18f804b030781b6a7496517ba26f9ff5b2 diff --git a/internal/guideproviders/main.go b/internal/guideproviders/main.go index a2c1460..c064256 100644 --- a/internal/guideproviders/main.go +++ b/internal/guideproviders/main.go @@ -35,17 +35,18 @@ func (i *Configuration) GetProvider() (GuideProvider, error) { // Channel describes a channel available in the providers lineup with necessary pieces parsed into fields. type Channel struct { // Required Fields - ID string - Name string - Logos []Logo - Number string + ID string `json:",omitempty"` + Name string `json:",omitempty"` + Logos []Logo `json:",omitempty"` + Number string `json:",omitempty"` // Optional fields - CallSign string - URLs []string - Lineup string + CallSign string `json:",omitempty"` + URLs []string `json:",omitempty"` + Lineup string `json:",omitempty"` + Affiliate string `json:",omitempty"` - ProviderData interface{} + ProviderData interface{} `json:",omitempty"` } // XMLTV returns the xmltv.Channel representation of the Channel. @@ -97,12 +98,38 @@ type ProgrammeContainer struct { ProviderData interface{} } +// AvailableLineup is a lineup that a user can subscribe to. +type AvailableLineup struct { + Location string + Transport string + Name string + ProviderID string +} + +// CoverageArea describes a region that a provider supports. +type CoverageArea struct { + RegionName string `json:",omitempty"` + FullName string `json:",omitempty"` + PostalCode string `json:",omitempty"` + PostalCodeExample string `json:",omitempty"` + ShortName string `json:",omitempty"` + OnePostalCode bool `json:",omitempty"` +} + // GuideProvider describes a IPTV provider configuration. type GuideProvider interface { Name() string Channels() ([]Channel, error) - Schedule(inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) + Schedule(daysToGet int, inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) Refresh(lineupStateJSON []byte) ([]byte, error) Configuration() Configuration + + // Schedules Direct specific functions that others might someday use. + SupportsLineups() bool + LineupCoverage() ([]CoverageArea, error) + AvailableLineups(countryCode, postalCode string) ([]AvailableLineup, error) + PreviewLineupChannels(lineupID string) ([]Channel, error) + SubscribeToLineup(providerID string) error + UnsubscribeFromLineup(providerID string) error } diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 5017fa1..e26d275 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -31,17 +31,109 @@ func (s *SchedulesDirect) Name() string { return "Schedules Direct" } +// SupportsLineups returns true if the provider supports the concept of subscribing to lineups. +func (s *SchedulesDirect) SupportsLineups() bool { + return true +} + +// LineupCoverage returns a map of regions and countries the provider has support for. +func (s *SchedulesDirect) LineupCoverage() ([]CoverageArea, error) { + coverage, coverageErr := s.client.GetAvailableCountries() + if coverageErr != nil { + return nil, fmt.Errorf("error while getting coverage from provider %s: %s", s.Name(), coverageErr) + } + + outputCoverage := make([]CoverageArea, 0) + + for region, countries := range coverage { + for _, country := range countries { + outputCoverage = append(outputCoverage, CoverageArea{ + RegionName: region, + FullName: country.FullName, + PostalCode: country.PostalCode, + PostalCodeExample: country.PostalCodeExample, + ShortName: country.ShortName, + OnePostalCode: country.OnePostalCode, + }) + } + } + + return outputCoverage, nil +} + +// AvailableLineups will return a slice of AvailableLineup for the given countryCode and postalCode. +func (s *SchedulesDirect) AvailableLineups(countryCode, postalCode string) ([]AvailableLineup, error) { + headends, headendsErr := s.client.GetHeadends(countryCode, postalCode) + if headendsErr != nil { + return nil, fmt.Errorf("error while getting available lineups from provider %s: %s", s.Name(), headendsErr) + } + + lineups := make([]AvailableLineup, 0) + for _, headend := range headends { + for _, lineup := range headend.Lineups { + lineups = append(lineups, AvailableLineup{ + Location: headend.Location, + Transport: headend.Transport, + Name: lineup.Name, + ProviderID: lineup.Lineup, + }) + } + } + + return lineups, nil +} + +// PreviewLineupChannels will return a slice of Channels for the given provider specific lineupID. +func (s *SchedulesDirect) PreviewLineupChannels(lineupID string) ([]Channel, error) { + channels, channelsErr := s.client.PreviewLineup(lineupID) + if channelsErr != nil { + return nil, fmt.Errorf("error while previewing channels in lineup from provider %s: %s", s.Name(), channelsErr) + } + + outputChannels := make([]Channel, 0) + + for _, channel := range channels { + outputChannels = append(outputChannels, Channel{ + Name: channel.Name, + Number: channel.Channel, + CallSign: channel.CallSign, + Affiliate: channel.Affiliate, + Lineup: lineupID, + }) + } + + return outputChannels, nil +} + +// SubscribeToLineup will subscribe the user to a lineup. +func (s *SchedulesDirect) SubscribeToLineup(lineupID string) error { + _, addLineupErr := s.client.AddLineup(lineupID) + if addLineupErr != nil { + return fmt.Errorf("error while subscribing to lineup from provider %s: %s", s.Name(), addLineupErr) + } + return nil +} + +// UnsubscribeFromLineup will remove a lineup from the provider account. +func (s *SchedulesDirect) UnsubscribeFromLineup(lineupID string) error { + _, deleteLineupErr := s.client.AddLineup(lineupID) + if deleteLineupErr != nil { + return fmt.Errorf("error while deleting lineup from provider %s: %s", s.Name(), deleteLineupErr) + } + return nil +} + // Channels returns a slice of Channel that the provider has available. func (s *SchedulesDirect) Channels() ([]Channel, error) { return s.channels, nil } // Schedule returns a slice of xmltv.Programme for the given channelIDs. -func (s *SchedulesDirect) Schedule(inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { +func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { // First, convert the slice of channelIDs into a slice of schedule requests. reqs := make([]schedulesdirect.StationScheduleRequest, 0) channelsCache := make(map[string]map[string]schedulesdirect.LastModifiedEntry) - requestingDates := getDaysBetweenTimes(time.Now(), time.Now().AddDate(0, 0, 7)) + requestingDates := getDaysBetweenTimes(time.Now(), time.Now().AddDate(0, 0, daysToGet)) channelShortToLongIDMap := make(map[string]string) for _, inputChannel := range inputChannels { splitID := strings.Split(inputChannel.ID, ".")[1] @@ -345,7 +437,7 @@ type sdStationContainer struct { ChannelMap schedulesdirect.ChannelMap } -func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo schedulesdirect.Part) string { +func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo *schedulesdirect.Part) string { seasonNumber := 0 episodeNumber := 0 totalSeasons := 0 @@ -383,10 +475,16 @@ func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo s episodeNumberStr = fmt.Sprintf("%d/%d", episodeNumber, totalEpisodes) } - partNumber := multipartInfo.PartNumber - totalParts := multipartInfo.TotalParts - partStr := "0" + + partNumber := 0 + totalParts := 0 + + if multipartInfo != nil { + partNumber = multipartInfo.PartNumber + totalParts = multipartInfo.TotalParts + } + if partNumber > 0 { partStr = fmt.Sprintf("%d", partNumber) if totalParts > 0 { @@ -486,7 +584,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program } } - if programInfo.Movie.Year != nil && !programInfo.Movie.Year.Time.IsZero() { + if programInfo.Movie != nil && programInfo.Movie.Year != nil && !programInfo.Movie.Year.Time.IsZero() { xmlProgramme.Date = xmltv.Date(*programInfo.Movie.Year.Time) } @@ -545,7 +643,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program Value: programInfo.ProgramID, }) - xmltvns := getXMLTVNumber(programInfo.Metadata, *airing.ProgramPart) + xmltvns := getXMLTVNumber(programInfo.Metadata, airing.ProgramPart) if xmltvns != "" { xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{System: "xmltv_ns", Value: xmltvns}) } @@ -603,16 +701,18 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program xmlProgramme.Subtitles = append(xmlProgramme.Subtitles, xmltv.Subtitle{Type: "deaf-signed"}) } - if !programInfo.OriginalAirDate.Time.IsZero() { + if programInfo.OriginalAirDate != nil && !programInfo.OriginalAirDate.Time.IsZero() { if !airing.New { xmlProgramme.PreviouslyShown = &xmltv.PreviouslyShown{ Start: xmltv.Time{Time: *programInfo.OriginalAirDate.Time}, } } + timeToUse := programInfo.OriginalAirDate.Time if airing.New { timeToUse = airing.AirDateTime } + xmlProgramme.EpisodeNums = append(xmlProgramme.EpisodeNums, xmltv.EpisodeNum{ System: "original-air-date", Value: timeToUse.Format("2006-01-02 15:04:05"), @@ -634,11 +734,13 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program } } - for _, starRating := range programInfo.Movie.QualityRating { - xmlProgramme.StarRatings = append(xmlProgramme.StarRatings, xmltv.Rating{ - Value: fmt.Sprintf("%s/%s", starRating.Rating, starRating.MaxRating), - System: starRating.RatingsBody, - }) + if programInfo.Movie != nil { + for _, starRating := range programInfo.Movie.QualityRating { + xmlProgramme.StarRatings = append(xmlProgramme.StarRatings, xmltv.Rating{ + Value: fmt.Sprintf("%s/%s", starRating.Rating, starRating.MaxRating), + System: starRating.RatingsBody, + }) + } } if airing.IsPremiereOrFinale != nil && *airing.IsPremiereOrFinale != "" { diff --git a/internal/guideproviders/xmltv.go b/internal/guideproviders/xmltv.go index 271fdec..34c1ae1 100644 --- a/internal/guideproviders/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -30,13 +30,43 @@ func (x *XMLTV) Name() string { return "XMLTV" } +// SupportsLineups returns true if the provider supports the concept of subscribing to lineups. +func (x *XMLTV) SupportsLineups() bool { + return false +} + +// LineupCoverage returns a map of regions and countries the provider has support for. +func (x *XMLTV) LineupCoverage() ([]CoverageArea, error) { + return nil, nil +} + +// AvailableLineups will return a slice of AvailableLineup for the given countryCode and postalCode. +func (x *XMLTV) AvailableLineups(countryCode, postalCode string) ([]AvailableLineup, error) { + return nil, nil +} + +// PreviewLineupChannels will return a slice of Channels for the given provider specific lineupID. +func (x *XMLTV) PreviewLineupChannels(lineupID string) ([]Channel, error) { + return nil, nil +} + +// SubscribeToLineup will subscribe the user to a lineup. +func (x *XMLTV) SubscribeToLineup(providerID string) error { + return nil +} + +// UnsubscribeFromLineup will remove a lineup from the provider account. +func (x *XMLTV) UnsubscribeFromLineup(providerID string) error { + return nil +} + // Channels returns a slice of Channel that the provider has available. func (x *XMLTV) Channels() ([]Channel, error) { return x.channels, nil } // Schedule returns a slice of xmltv.Programme for the given channelIDs. -func (x *XMLTV) Schedule(inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { +func (x *XMLTV) Schedule(daysToGet int, inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { channelIDMap := make(map[string]struct{}) for _, chanID := range inputChannels { channelIDMap[chanID.ID] = struct{}{} diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index 49c0e2d..f4e433d 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -64,6 +64,11 @@ func (p *Date) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) dateFormat = "2006" } + if strings.Contains(content, "|") { + content = strings.Split(content, "|")[0] + dateFormat = "2006" + } + v, e := time.Parse(dateFormat, content) if e != nil { return fmt.Errorf("the type Date field of %s is not a time, value is: %s", start.Name.Local, content) diff --git a/main.go b/main.go index b3c5e42..5f05c05 100644 --- a/main.go +++ b/main.go @@ -113,25 +113,25 @@ func main() { for _, lineup := range lineups { api.StartTuner(cc, &lineup) - // videoProviders := make(map[int]string) + videoProviders := make(map[int]*models.VideoSource) guideProviders := make(map[int]*models.GuideSource) for _, channel := range lineup.Channels { - // videoProviders[channel.VideoTrack.VideoSource.ID] = channel.VideoTrack.VideoSource.UpdateFrequency + videoProviders[channel.VideoTrack.VideoSource.ID] = channel.VideoTrack.VideoSource guideProviders[channel.GuideChannel.GuideSource.ID] = channel.GuideChannel.GuideSource } - // for videoProviderID, updateFrequencey := range videoProviders { - // c.AddFunc(updateFrequencey, func() { commands.StartFireVideoUpdates(cc, videoProviderID) }) - // } + for _, videoSource := range videoProviders { + commands.StartFireVideoUpdates(cc, videoSource) + c.AddFunc(videoSource.UpdateFrequency, func() { commands.StartFireVideoUpdates(cc, videoSource) }) + } for _, guideSource := range guideProviders { commands.StartFireGuideUpdates(cc, guideSource) - // c.AddFunc(updateFrequencey, func() { commands.StartFireGuideUpdates(cc, guideProviderID) }) + c.AddFunc(guideSource.UpdateFrequency, func() { commands.StartFireGuideUpdates(cc, guideSource) }) } } c.Start() - log.Infof("CRON ENTRIES %+v", c.Entries()) api.ServeAPI(cc) } diff --git a/models/guide_source_channel.go b/models/guide_source_channel.go index 592d14b..3dab30a 100644 --- a/models/guide_source_channel.go +++ b/models/guide_source_channel.go @@ -84,7 +84,7 @@ func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel gu } res, err := db.SQL.NamedExec(` - INSERT INTO guide_source_channel (guide_id, xmltv_id, data, provider_data) + INSERT OR REPLACE INTO guide_source_channel (guide_id, xmltv_id, data, provider_data) VALUES (:guide_id, :xmltv_id, :data, :provider_data)`, insertingChannel) if err != nil { return nil, err diff --git a/utils/main.go b/utils/main.go index 945a83f..677ceac 100644 --- a/utils/main.go +++ b/utils/main.go @@ -273,7 +273,11 @@ func PadNumberWithZeros(value int, expectedLength int) string { padded := fmt.Sprintf("%02d", value) valLength := CountDigits(value) if valLength != expectedLength { - return fmt.Sprintf("%s%d", strings.Repeat("0", expectedLength-valLength), value) + repeatLength := expectedLength - valLength + if repeatLength < 0 { + repeatLength = 0 + } + return fmt.Sprintf("%s%d", strings.Repeat("0", repeatLength), value) } return padded } From db7da3bcd3e84858fcc17063c1683caab3d7b4cf Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Thu, 30 Aug 2018 02:44:04 -0400 Subject: [PATCH 095/182] fixing context error --- context/context.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/context/context.go b/context/context.go index 01e61b2..fe0e1bc 100644 --- a/context/context.go +++ b/context/context.go @@ -69,7 +69,7 @@ func NewCContext() (*CContext, error) { } if _, execErr := sql.Exec(`PRAGMA foreign_keys = ON;`); execErr != nil { - log.WithError(dbErr).Panicln("error enabling foreign keys") + log.WithError(execErr).Panicln("error enabling foreign keys") } log.Debugln("Checking migrations status and running any required migrations...") From 8fa825697c9d7bde850337f67a7c992b95ec6cdd Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 30 Aug 2018 14:54:38 -0700 Subject: [PATCH 096/182] Ensure SD client is always initialized before attempting requests --- internal/guideproviders/schedules_direct.go | 53 +++++++++++++++++++++ 1 file changed, 53 insertions(+) diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index e26d275..74155ca 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -38,6 +38,15 @@ func (s *SchedulesDirect) SupportsLineups() bool { // LineupCoverage returns a map of regions and countries the provider has support for. func (s *SchedulesDirect) LineupCoverage() ([]CoverageArea, error) { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return nil, fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } + coverage, coverageErr := s.client.GetAvailableCountries() if coverageErr != nil { return nil, fmt.Errorf("error while getting coverage from provider %s: %s", s.Name(), coverageErr) @@ -63,6 +72,15 @@ func (s *SchedulesDirect) LineupCoverage() ([]CoverageArea, error) { // AvailableLineups will return a slice of AvailableLineup for the given countryCode and postalCode. func (s *SchedulesDirect) AvailableLineups(countryCode, postalCode string) ([]AvailableLineup, error) { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return nil, fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } + headends, headendsErr := s.client.GetHeadends(countryCode, postalCode) if headendsErr != nil { return nil, fmt.Errorf("error while getting available lineups from provider %s: %s", s.Name(), headendsErr) @@ -85,6 +103,15 @@ func (s *SchedulesDirect) AvailableLineups(countryCode, postalCode string) ([]Av // PreviewLineupChannels will return a slice of Channels for the given provider specific lineupID. func (s *SchedulesDirect) PreviewLineupChannels(lineupID string) ([]Channel, error) { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return nil, fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } + channels, channelsErr := s.client.PreviewLineup(lineupID) if channelsErr != nil { return nil, fmt.Errorf("error while previewing channels in lineup from provider %s: %s", s.Name(), channelsErr) @@ -107,6 +134,15 @@ func (s *SchedulesDirect) PreviewLineupChannels(lineupID string) ([]Channel, err // SubscribeToLineup will subscribe the user to a lineup. func (s *SchedulesDirect) SubscribeToLineup(lineupID string) error { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } + _, addLineupErr := s.client.AddLineup(lineupID) if addLineupErr != nil { return fmt.Errorf("error while subscribing to lineup from provider %s: %s", s.Name(), addLineupErr) @@ -116,6 +152,15 @@ func (s *SchedulesDirect) SubscribeToLineup(lineupID string) error { // UnsubscribeFromLineup will remove a lineup from the provider account. func (s *SchedulesDirect) UnsubscribeFromLineup(lineupID string) error { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } + _, deleteLineupErr := s.client.AddLineup(lineupID) if deleteLineupErr != nil { return fmt.Errorf("error while deleting lineup from provider %s: %s", s.Name(), deleteLineupErr) @@ -130,6 +175,14 @@ func (s *SchedulesDirect) Channels() ([]Channel, error) { // Schedule returns a slice of xmltv.Programme for the given channelIDs. func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) { + if s.client == nil { + sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) + if sdClientErr != nil { + return nil, nil, fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + } + + s.client = sdClient + } // First, convert the slice of channelIDs into a slice of schedule requests. reqs := make([]schedulesdirect.StationScheduleRequest, 0) channelsCache := make(map[string]map[string]schedulesdirect.LastModifiedEntry) From 56a2c0d7caea07d7dfe0edcbe2df45ec5a559fde Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 30 Aug 2018 15:31:47 -0700 Subject: [PATCH 097/182] re-enable video sources --- context/context.go | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-) diff --git a/context/context.go b/context/context.go index fe0e1bc..a29e800 100644 --- a/context/context.go +++ b/context/context.go @@ -108,22 +108,22 @@ func NewCContext() (*CContext, error) { guideSourceProvidersMap[guideSource.ID] = provider } - // videoSources, videoSourcesErr := api.VideoSource.GetAllVideoSources(false) - // if videoSourcesErr != nil { - // log.WithError(videoSourcesErr).Panicln("error initializing video sources") - // } + videoSources, videoSourcesErr := api.VideoSource.GetAllVideoSources(false) + if videoSourcesErr != nil { + log.WithError(videoSourcesErr).Panicln("error initializing video sources") + } videoSourceProvidersMap := make(map[int]videoproviders.VideoProvider) - // for _, videoSource := range videoSources { - // log.Infof("Initializing video source %s (%s)", videoSource.Name, videoSource.Provider) - // providerCfg := videoSource.ProviderConfiguration() - // provider, providerErr := providerCfg.GetProvider() - // if providerErr != nil { - // log.WithError(providerErr).Panicln("error initializing provider") - // } - // videoSourceProvidersMap[videoSource.ID] = provider - // } + for _, videoSource := range videoSources { + log.Infof("Initializing video source %s (%s)", videoSource.Name, videoSource.Provider) + providerCfg := videoSource.ProviderConfiguration() + provider, providerErr := providerCfg.GetProvider() + if providerErr != nil { + log.WithError(providerErr).Panicln("error initializing provider") + } + videoSourceProvidersMap[videoSource.ID] = provider + } context := &CContext{ API: api, From 33776a1815ba31f7129ad5eb1475dde0e03b1187 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 30 Aug 2018 16:30:36 -0700 Subject: [PATCH 098/182] Update frontend --- api/a_api-packr.go | 4 ++-- frontend | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/api/a_api-packr.go b/api/a_api-packr.go index 8ca0c66..97ea389 100644 --- a/api/a_api-packr.go +++ b/api/a_api-packr.go @@ -12,8 +12,8 @@ func init() { packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"H4sIAAAAAAAA/+z9+6/juLUniv/+/St0qlHo2mnLLcmW7W2jG8nJNwcTIJ0LnJwB5qKnJpAt2lZKr5Hk2toxfP72C74kPhYlSntXTubiptJVMrm4uLi4uEh++PrxN//y/3N+4/xrUTR1U0Wl83W99Jcr59O1acp6/+OPF9QceeTyVGQ/PmH63xfla5Vcro0TeL7vBp6/c/7jigQ+v7s116KqjcQvSdOgauH8MT8tMdGfkhPKaxQ7tzxGlfPLH/9DkCFprrcjyb15OdY/dgL9eEyL449ZVDeo+vFPf/z9H/78lz9g+X5c5he3Rik6Nf2XW5QoR/HPQsipyJsoyVF1P0anL5equOXx/rvz+Xw4FlWMKvdUpEW1/+64wn+c706nk/Nd/Iz/PKZmsb8WX3FGRevW1yguXvZ5kaPJbBwcGFVV8XJvinLvBmUrC9tUUV6XUYXyxhG/v3t+fuaUL0ncXPeeE5Yt/u8NQnSlspFgs9kMZSUEHIumKTJDVdG8KIlLDMutoji51XvvIEem6NzHWWbdFOVgvk1RGjLFMRY5novTrUbxPi+aT5ogT4N5M3P0vC0iNtqZUpLXqHE8xy9b8l91OUafvAX+s/S24dPCc/CfVR/lB5tFEIaLpf8EixkndXRMx9sLF+r8jP8IvIiRXKPa/RqlN0R+lWl0QtcijVF1j5O6TKNXtRU4ttl1jXSPC1wXaRKTBnrIkty9IlxD+9WmbA9RmlxyN2lQVu9PKG9QNZad3lSpZj1Zr5unMUYkkBRfKIsuz6GM4jjJL8R69r4ntUhrxpqGmaaiKIJruE7yS4pghQsKnJzYKFySl7fmTgrp6WXuQkjr2oc4CLs4o4PKbmmTlCmyNVqjXCTMaNKAmaEV/vOPkEqITaMjSu9MSdR5D0tgb5JSXWyFqrDS/zQjoMo+Fzm2ob+j/fIZZYcsqi5Jzmu+bHkA9eMkBKie8Bz1XTVzun1/KPmFAHnn87sXo4/kVfzeVvQuQpmMiNb3t6hfITY5FfniG/KnJeK9SZKnSY7cY1qcvhy+RVsxlpF3Glr9xzsUneNvnf0S1yUfJ9B29O3tX5WB5MuFoI79W8pA+xNuzMxXrAT3RURYvW/diz0sc48HRYRwWATC5pSiqHJfqqgs+676+VkbQEl0fQizNm5inhf4R23QUCZ5jir370WO7krnOujj++F9J6CenM4hgrGUVFBh1iIMlpn08rRAZ6En7tXlGCYbvFeom9cU7YkFypMfNvVxgiUvQVwVZVy85G4Z5SidNOS0HCnKOWjTHWJOvud9POg6Qhv8h3eLZObng3JrXB2dhg4+SURRNkmR79OobtzTNUnjoenVup9rAhOs9Zg8TVHeWQtRS2nKRp1S6RKA+mG5jKuoKUor/ZyTSlXQRLEBOeScryiK1dmtame8Q8OGu7XgeS6KRpq5vpWhoJ67rGtY1aPKxS2svLsv6PgladxbjZssqRoyLzy4WfF3KLTWA7UAXrYdnhPjyQQZc74gNrvwDtR0xIYarp8Op1tVF9W+LJJuqjinTL3x9GNDxjpG5+iWNu/BOouqL+CgEx3PIets35gFVSk8sqUDcFGvG8+bk2lS5AaHq1fSbvuk1e3MPKFisrxXq5VxyvF+uQmxbCD7Psq0N5FDX96359VbOmV6Op3ezpR6XWk8FQSzq5x8NtFFmQn145p+ZrrzPkq2vfa8x74qiubuusf0hggQdzyfD66b5HFyKfBQxvfOwcF1y1tVpmj/3ea8Dk4+DkjyL/vv0G6FdqeD61Yo3n8Xn1bhOjy4blFF+QXtvzvHW+SvD677itK0eMEt4OR724PrXiqE8v13wS7akhQNitL9d4F3en7G0afXKN9/52+j4Lg7uO7LNWkQbT84afS6/25z2obbmP1046j6sv9utV5Faw8LVyVZVL0KBarRqchjEtalrG+nE6prQYokPxditlGV41bZix3jclVCSVOiye/Ou/PzOSIEkiDHCkVfiOt123qvhNTZPtxuylYOzeL9drNTQ9PL/vk5UEPbdO8HnkeCSc2eoyxJX906ymu3RlVy3rtRWabIrV/rBmWLf02T/Msv0ekv5Oe/FXmz+PAXdCmQ89//+GHx78WxaIrFh/+G0q+oSU6R82d0Qx8Wv6uSKF30TBcffoeZOr/HrcL5Q1b8LfnQ89ED/vKaHYv0w+LDn4umkFIpcmdFXtRldEL7v/zbL0VeuP+OLrc0qha/oDwtFr8UeXQqFr8v8rpIo3rx4U/JEVURaQaY/MPiw++LW5Wgyvkzevmw6Ng9frPY76Nzg6rFfn9E56JCFA1N/o7rtxujtI9rk6V3MuVmiKG/9MMD788b1NK25Ebx3251Q8d9uPs2x+DpwjktXvjQ/VQVaXqMqp5pVLrX5HIlpqQvOTx+i7l8TdBLWVTNnY72Y/Q1OSE69H9EVZOcUrSI6iRGi3NyOUXENeDPW4UWdNS0oAOyxZV0iIssSvJFHn1d1OhEuiuOOBCo4XEs4lc2Itp7B6GO/tkNqnd3foUy1d8d5KoNeW8R+EEYPB9ILRI8e4/9MtRhns+PX5vomOQxan/64PofPu/JAsi9uDWY+d77lyTDNRXlzePqL67B4rpaXNeLa7i4bu7ChMd7xOmiSBfl4pZK4cqoH5fjER2P1a9x1ERuUSWXJI9St0maFH1ekBj6fSfyx+hU0EaxJ2uPWCrZgiEKJy6aBsWHUQI26LuitJSnLnvvEcVxhWptKN1VBG0CeVFlUSpVRZJfUZU0jyJ1CqwU55YubuT7hr8Vht4jbqSBxdbzHnGsUC3DqkdiKUj/IMb9v29Fg1jj6Gzc8Ryi6Pic3wVZkyZKk9PjuKibqsgvUq5HApo86ttxUd/Ke1nUCVFZhdKoSb4iwRa34UepvN7hK8KtNkqZuR2jGmECzI1PKt1lEKLsgXmTCfIS/4ru/aIZ7trU+iJTBc1uRSTBYApu/SUp98Xxb+jU1I9IBmQ8L9wcV2bjeERk+e/Xa4XOn5/oN28ln58Wg7G0/YzQiNIwYwGLPiyI2lQfpyJGiy/HeFFWaFFHWXkXXd37dkKia0LZo+yMz9jqD7zv2Ee3phjsTR5JdrkrNpUlcZwiGTkiOqq/Xu4d62sSxyhX7ZGmfTR4+CugVGlU1mjPPx6so7mL0NtyS9qdAiGyUI6Q0SGY6m4ZOxf3Y3ua8NFc7wIZ9xPHW9PgKZa0VOKxYKWWqd9y/LI98CDeBAihW2E5iWQO1jMB1ymnBUFkF3wWuaDTnAUWKKpQBHeQ3Dz76uYhkMcTM+or5WtSJ8cU8ViaL1UEacrnospoXf7avJbopwrVqPm8oD/q2zFLms8LlhgPaRwaQ0M+d/hEVJYoqqL8hPY06iHR7fcEr6BaItjrQszOGM0EAOJZBWkR/TIgYK5EN5Tz6YpOX45F+3khBOLqLz7DA7p+zURkE0cNkljggCbJkJsWpyiVorIib65SCCYEdZgmdYMHkZ19yO23QsQaeEt7nBOUxjVq7lmS8y0svbyHzrgYRus9UnRBeSyP1BhuTYabWdS6wk+VldwxCt6IBgDWeZAdLpmGuXSATjvxR1kVF9Llm/ozqrL8lh1RhS2CaY0i+XWJpaJmaiAsbo1MyJfysUoZ9xpF1en6mbd4tzifa9TQvURANQnthqXss6MB7gkTprJoJtq+B4JsgmTWpzknKXJvZVpEMS8ProhOxeaWWdwa7CKghcFHfcvwfLeLxIZIkAIV/WtQVqZRg+TdKr/SPuCzFCoMY5dXf7G8BovldbVYXteL5TVcLK+bhXF4qxsa5BsF6FIelgey3ZH8r76wxh4Qzg8s0zUQw2noanFd3UX73jLy9eK6vquG/8DFuYZSeMAiNrhQ8pTisUxRFOvUUplWnvdYMm26ouQbgFItfZ9SLFu4hHIxpxU1sJ6YVlTSyi7ttRId8KnIG5Q3xAN3Q161dxNXf3xhrC6OgLjvO4CYvwij+k+PZZ1Fabogf9+Hca9lFlVfFvivrutZBjg/fcZ3Ou/Q6rGkbYq0ugX9cctJJ6VgeVg1dSP2X2JS0irhRqyRkdGrsJT1dJe2lTDjTfKkSaI0qTOhyM/ex4MyWriVJapOUY0ey34WZJ6pSe2gT8CXYOQ+SNa1NMgDEncQDLOS/Yf/GXj+2vmfnvc778NjmWQX95zeEjyhkzo00fMTquZ6y455lKRCJRJrtV3sjBEK0EbZcsN4DGXOJo9wPdJIF4/IIX8otZyOmg+l5TqUVYlnK6Jdb5dhR8KQ2JeiiilCuCd/uzjgEf1Mkspe9csxFtRWocxZruX6lzIgCtTUyoATVYHYar4cY0fMwxMty1PaJJ7Bl4JGNbsSRaGZYnpHUYlh3NIrhQ1blmWFXDp5IjMcXNd8i+DawzMFPs96ZXOsx7LfXqaPsfgOFW2nhC9s/qo6A5JQCWJRv81QnETOp34oSKDhp7uQbW+QIZbxASQiyLEh0TYwJCLAsiHR88aQiOLOhlS+TwXsI1mD/gaaW1bFS2c25xS1B/wX2Wuxx3/JPFyRLWFCQh7LvHAvt6ZBVS17WU9BkATCn5enIl2IAb+e0qiuf/PTqUjdz8pajLJD1HvQ1JjUZ/947F/+O6D/sn9W9J81/Sek/2zoP1v6z47+80z/weqhX+mF/8vzwl9e/ymEBt1n/7XqvtbdV9h9bbqvbfe1676eu69enizm/3J58JfXfwqhQffZf626r3X3FXZfm+5r233tuq/n7quXp874v1we/OX1n0Jo0H32X6vua919hd3Xpvvadl+77uu5++rlaVP+L5en7c2j7S2k7Y2k7eyk7Uyl7ayl7Qym7Wym7cym7Syn7YynpfYDoJrihLPfmu5rG57hJk3M/k6a6DGqkxp3C/jHpSpe9r7S6T46OyYpCEpLvAAlYQ6Bp6CDLdJyevLdcsX+J86PhVCaIuhT+Jvlhv5vK02phWCaZtWnCUKRNAgZxbqnWK1AQcRgmibs06x9UBIxmKbZ9GlCCQcIuQ63AgWsklDTya5Ps4F1stF08tyn2Uo62XKd+J5QObBSdppSfKFGn2GtPGta8cVK1fGRx5IOWsheqDsdGro+D8XDbhbor3igd+dQDAvwOQkPCFhAwANWLKDjsWYBax4QsoCQB2xYwIYHbFnAlgfsWMCOBzyzgOdOMC6q38vaCdtJ63NxfSwvQU1c/y52eJJRMIpAopDbBSNZSSSkPbCYtRQjmz8jCSUS2doZyUYiIVbOYrZyDCT/TiLZQPI/SyRbQX7fk/UDFcCXdShZ5tBAD/cC01wj6zWmeUfci012kLi/m+Ejcec46iZxvznDU+JOdoazxD3yqL/EnfUMl4l79hleEw8DRh0nGZLM8J1k/DLDfZLBjpUHrTODE60z2I/Wme5KiVUq3pQYneJQiUUpPpUYkOJWiXUonpVUveJcSU0r/pVUo+JiSR0pXpZWiepoqcJVX0vVqblbogplitFHjTtjoqJRf0yUZnLJRHujXpnoc9QxEw2bfDNR9ah7Jsof9dCkOkxOmtbLqJ+mFWV01YPzazyDmOar2Yxjmq/GM6DJvhrPlWb4ajyxGvXVeM41w1fjCdoMX41nc6O+Gk/0ZvhqPCuc4avxFHLUV5Pp7AxfTea+M3w1mShb+eosNvjqLIZ9dRbrvppYpeKridEpvppYlOKriQEpvppYh+KrSdUrvprUtOKrSTUqvprUkeKraZWovpoqXPXVVJ2aryaqgH010ciYryYqGvXVRGkmX020N+qriT5HfTXRsMlXE1WP+mqi/FFfTarD5KtpvYz6alpRU3x1D2umbnqZ5qsZWjXNV6eXGb46vczy1enFwlenl1m+Or3M8tXpxcJXp5dZvjq9zPLV6cXCVxModIavJrjpDF9NQFYrX51eTODEBfbV6UX31cQqFV9NjE7x1cSiFF9NDEjx1cQ6FF9Nql7x1aSmFV9NqlHx1aSOFF9Nq0T11VThqq+m6tR8NVEF7KuJRsZ8NVHRqK8mSjP5aqK9UV9N9Dnqq4mGTb6aqHrUVxPlj/pqUh0mX03rZdRX04qa4quF1aTUbSfiw+0ciLidgxK384Di1gYrbufBxe08xLi1AY3bebhxOw86bm3Q43YmgNzOxJBbaxi5TQ3Ouk1hZ92murMmVqk4a2J0irMmFqU4a2JAirMm1qE4a1L1irMmNa04a1KNirMmdaQ4a1olqrOmCledNVWn5qyJKmBnTTQy5qyJikadNVGayVkT7Y06a6LPUWdNNGxy1kTVo86aKH/UWZPqMDlrWi+jzppWlNlZL9ke8IEjBYzGaeIF/7qqG0KbooT3cLE9OB2PK4piID3dQqOcOAmMXI5F/PoD+Vs8LW6kNxWSnPehkW6d9QUkP6799pkV2SZFo2h+qCPlv4XUfdD1btqUpLLjmoGYMJXJNwmw/qVsZU4pqmtRPwsgNoYCr2CglDVut0w/TZWUWDachdNU+7y5usXZbV5L9KmI4ydd19INE+ET50Tv2+j4GG6lUS+I46nZSdCF/PPnvoRdyBWo/eMujnoDYDd/SOmoPItRCiHHISJIiOfzKRaskB9kXagBQhZCGMQx3sS7+AgWqz8nay6YQmMqmkYGiXLanY6nvnD0RO5C/ikWjIeAvFZoczIUix31HSiUSGEskkwEmowfn4+dEEl+LhbCt8CY/gRZIBQiuBzkgLK5EH20qQQiBZR3dIxjFPK82QHohfxT4N2FQLzOZ4SOEVgOfrLaXBSJwlQahcggxC7yuRD0/PZC+iUw5wEgo/Bksi52KtxcGJHAVBaZBpTAP3rHLZeAHBdeiD8Ezuw3yCU+x2cEloMeZjcXQ4g3lUIigbJHJ3Q6b/r6qL4shG+pLvBPsJ1vTrsTbFfk+P1QPfBocy30FGDbfD4ej532olOTfEUL6ZfAmQdcwaxo7IC0IoFJXpkGkNjQMTpL0nWT8uL+e8ImX37BRrDarZDCjlS/wG/9HHrhFmCJntEJqdcSywMfLJqNXCK9I9uPMGhhP+WRElQUQqkMsbThjUAzd6QThOGC/yeOdwTWE4Y+Mjdczx3I0s/Ut+Hyma5fUv4Vqssir5OveDxrPlbW7YVu2TlUfjSrO4tKdkhjR9wUt9MVOqiKg3Dia0K2A/bnViFRfjaqHyjVdrM1liobOCz3Dy5VFk8q1fOzbyxVevmnKVV6mVQq339+NharTf9pitWmA8XSyP9ZxDbLvDwXVUbufayKAS2zrbynKD19CugpGOcHJyjb/oKq5YqcpXPYeW7ltg3D7RrGXkB162lS7vuD4+DFtyhex9GBgA90X7Loyp2lH9YOimo80HWLW7PobzLU4rh91qcKodyJ8tj5VFbojKrarVB8O6HYzQq29xn/fLrLehSEILiyrOY9qTnUllEO3FalX+2oVhM7xW6jwu4+A/niRvyHHuzp7khf0Q4iwN2NImx3MLe8NdC12+zMflFGp6R5JSeXRAa4sHPTvi3x9CT8Wq+FFPxrhaK4yNPXz9CwlY5Xeo7s9lW9xmhp6K3QFpUni0bOB8tiueQuLWOjpTA1SSDfANYUJW3JvMn+4PhCS+YQGkSi3LYycpOBvwxVIXAXpcsxKoVIoJ+vHcuzzoA8g9FMAzjX5W4L5yrVTZlGSd6gtjE7VelujBV8OQYLVvU+fFmRjU+hXhO4R5YJWLaOZyqSHJxeFlZ0Qi2Yzj2p9GK34y93Ptzx0FD17gJDNYEHEtUC3eX+brcF8yWB8MHYsVwJKgw4il/5Tc2fF1AszuJzd8mI3OfIp1BxDL1xFLgyikYDxikcu+YHfAnptIN02jk6criHM2Jn47qfQyfjtHNCPSdy3wdwBkkukHzISCoTYcAv1uZsomNdpLdGOoBOKks5GGji1HUg/ylGUferHH7W4tWbrGTm2KDUU8WkKsYe2fDk2uE3HmjMnQG11E3UJKcDdCkR47ryA+BSreXXKE1i94xQjH2SdIuEfD2JYnfwuXF6GyPn2hQFbitA5XW3S//dJdc77cODlLPhNhTJkYgi+XaeZQiRIOOstbfwN9vF5nmxfH4Cj5Y/lqdb3RQZv8I9IeOFRBmPCMEvEfuMyB2rUuo9TCMNTEi4AnpwNcOisEu5YIF45LhYBkpdODbahUQcHNQKyiaDWrg0/6mY6GKEjhmdofg6t0Gyjtm4unTO9mlM2ei6Hs3FnIS3RvmySH0Ia6krmNamJCTljOIA6QbL1PtJQUzVqRtyFDoMQ8K70hYH8oTVOEA6rEVdNislmpIZdMjMleteFVSJhnUJ8dgPMFB1OkMGfkHJm2XpL5vVpn5bP4530ah4Br81TD7icUDx7RzPQNI5JrAnBoXerxrsGALVsVqfULgdE5d0Uu8nrAW7u9b54TkbHn0sbPtCcuWYwexJ3GC761PvTUmHBxZ22fPrmedLwTjIwnQ3iA0JY2hjA7QjDUyX1q51mdINNy1ATsWypteykYFujwMGmOTvOzOgt673fP/PmxsEgbcIVxPnBqy4+jCzixgcJZqopFEeI1KaMle4SSTTLEGJthHPZqYgkYKiDs4VBOXDcwXG/z81wwXmCxqtcc4wwHWU1G7uMJDDtHRWcwj73IaTTZlLWOrQTG8/p5hXPEPaCXOLLu302YUx6V1px4P5mlQ7Qm49z5iq2KGkEwebXfr5M45BFqqeZ8kxbQRpxQpayDpHQfRsIaLRB44nmTT/mOy8RpLPM433nIlMYglV0XrjbeJxkd9tNjKB4ZT5iKG/lcerqh1PGquaEw8PZGxFsJ+VjPKYMi8Zb4Mj9Pbzk8mtbyjtlHkKbHNzan/eXEU1TtLnKAsw/SIYuba4Kl4cshAGvcAupBc7MOHGy4Grn8TE8vu/psWfv93qJjm/uvwKXRYMry5JYtH1Qq2I/cFJqwLb5KTuN5LeMhaOZ8JPT5gZAqvuygW8YkppyLuQ4+ieE6qRXiBzZc6sFaGs4Fr4+NJct/A5sDgHLs1BquD1Yl2AQTaGdc3H8tjkcNWrbzIJ73twhUkPDRAThN82+SYPbWq7zsT9E4aNcCoSIOwNM+1MU/p9aO/aP3BnG64tfUPbscn5xBx/0h3I4Ls7OH4pkCov7UzamYZZ9Xu0MLfuIUa+AWu5Cal05I50Hk0f/OnSPt2V5w8imTV/gKNL7xCCOyN30VeUN3VfPn5a6y5u3xLChfJ3B7s4VmFVelb4jp+khI6l+iolvDmevQ8lj4NooJTJsAaX/IiDdYo9T1Ffi5ef5eLwpyyb4nJJ0Zj8m4A8RS3LH56OM+TfAzVjUwqebrQs8+q5OyI3rAq2nVFWRXe9vshHfrUL5hZGm2CzU7iF6/C4CRRuoj33WYyX1Pd2C9/fLvwAKqti1T1jO7ueoAx7y7ZMA9i2UKwp1k31rZRijcIwPM4pxR6sqXkWbizR7JqnpyZHzvLwvR7QUpLAxcbCA3+3W6kW7qMtWq0lXpJ9M/bjZRRWOZQSqpbNWNrZtbUCJli1TQrIpnlxplg01a+q9NN2vfKmy78HamamNcNlmVfPSX4uRrRA3w5WtEACexY2NuyvduvnjcrI30a7Y89INGDCeLxUwWrhb4KFv1vLxVJsl3CzM1y7Ittb7Tg5YLK0CJPslehSFdvbetvzRLH3ai3Ms1SoCDMrlJ2Lvo9sGOfvWss6oIESI9lgjeyQF+08Tz3UuXpGniexE82W52BR0DBc+M+rxVYrp2K7nKVqvm9Xg70RW6UA7LgrEWzKxiJQLStFOG2eQ0X1kw16SkF0mzYUZ15t0xPyw626WwaG0N+eiY0HPu2C1WqlsDrGgc87NMpKNGbG3KJ0Pfool04xZcbQzhHblt3eim0SAEbMizLFHVPFqtoO/HMQTxZ+r1fJPPOFCzKvfsnR+HFXtDs/nyPVFZFAgY2tPw7QBqnM4gh5KBSYiQZMuVuUb71bBOvnRRB6SgkVA6YM7T2xXfHtLdiCHjBgVpKpPphoVuv+4uf4PFX4vVYn8wwYLMjc+h2/kGG1XkVrtRHTwJ6F1QxuFWwDbXAWB36w7hnJnrf6YlGuMFiEu8VmLRdKc7rVF0uXa1fgKQ53jBx0t7gIk8a+RJPakN2P/Hii2Hu1DuY6Wr0Is6qTPwGsILUcDB08MtlHJll0QeJiAISfKlnZmPUoJqvwFC1czW4W4Kjylw1fzUJtAxZahFVj3wAmpQTaglbAaZDztOqZ3ELmlE5vLCNlfJtlaJA0x1vf2nREiFbLzKbxjAK/Gleo+bwZx9ZzgRuRGde20KhJTdMb0nxkGyjolMY0vbpmN6e3It6jJX2zrcgIOId639qkRHRYycpqkDWGOCs8web0Fthc5W9oSAYY3UKLsGpmNKKZQLpWwCkNaGr1zG8+bwLYR8r4NssQAXeOM7+11YjQtJiPFSo/hnWLDKH28gaUXmINNxUQtbfQG6CM6Y1kFm4vF2rSHGZKVcxuG2/A84eK9kYTUPB9jl+/tWWIkLeSlSXiNIqkK2yhJvKmFQGVP9xOTCsEFoqEtTO9tcxdINAKOBGkmlpDs1vO2xYORor5NuOQFxI4bP7W1iMi7XJONj3LKHgvs4QazltWHxTucLMxrEZYKBDUyvRGM3M9Qi3clG5mYr3Mbi5vWqcYLuDbLEJat+D4/Jt7GgHSlzKy7WfG1gkkplBjedNKh8wdbizwyoeFAiGtTG8q8xY+lIJN7Vsm1crspvKWBZHBAr7VHMQFEr4y8NaWIi4miPnY9CmjqxMiQ7hHmbmqIjE2dSbAKouF1gBVzOlIZqyzyIWa0olMqog3dCGz11+GijbLANIk/3JXD3pMXUbATGQ797xwc1wd1BMItzxGFS6AzaWYQ7nJa+E5N/6B/AwsxfMO/fkBkoW6QJ7rzYBhp8ZzCOTEErl8+9jkjM/l/m5XVgp51JmQR3+357tcx4lZkhNBA5fbdjQ/COTizRzkzgxyWurX5rVEPx1vTVPkn3vqhRBZoRo1hrj6dswSMVI8urc8RzESz8ewcyj06A0ubVTNuk9aYcvvkY5iRJsubqJP3akXj1x6m0ZlLUWLV5t0FEl+Ac6PsTrxuqvJ99ckjlEuHliiNM5yFdaPzhksyFeKzg39qujzI/jzVuoZPTQvwo7BDhwG9HrpxFNsyyAMUaYeAGOh/KDahw/i62LLFcro2a3O8tgFljwcuhO3u3eX/aa5g0n04qGsbF55IZVDeB1thvLb0G017CpPfmmN73mefG/NOS2iZo/JDsLjmZ5wpzBr/VyF+yW7TtdzPPW2dnk4J5zCI/zTpG7YFfR0WPL229vFt0j80HT/jaQtWnF3fpUwURA9o0ktz1GUi1VJDlrym3CV64U85eAqUw/A7r/AbL0Z1qqb+qjZQsUcM9+KugRd2d6h6m4kptVjVDkVTFS4yvWddD7mFCB1cgszaRdKo2harWuD6iw1jr+HFN47DPbGrfFgsKhxhaus8HexZ7kzGsiTXSgxqZa7o85vq2a90QzXN1yxcLmsO4JfW/raQYby5n/9RAX4vBiiwWyGKUjxhkmaovx8F9osK3nvVEm6OPmaxKi6KxXQ9S7q8AF+2pO+miCwTRo08NCQMrj06ejylKKo2h+L5qqdHDf2YPydAuAgueVTHJLIfMIkB0ozE3/j7/yjNjMxdZ0MFJEYdjNVORsaKk4wLTPhO5fkTPrph5zNrF0qkp2R0ah6+UdHcUVRLDh16eZ2PmVZgs8g6NMLWUS9kpUyQ5fgG2xNNChhHrQQpkTcGQxcSy/e3G643ULnJ0y0SAT5DWTCbuvwHdpkDYwk2AOI34/FCzNhKJo9WydLq2dqyAvOQuB878bAQgkd/PmDoqY+UKsqp/8EUwlR5moGMwViRzjAYhhp5Gcd2HsEZUuV0RRFeoyqwcca1Js8SHTdRFUj8TDfgaLWVVLVjXu6Jmms9moyJf2kOFQa8TRPoHVrVAyvkrvUJ+EJZ9qB8ymDMlxTIockE4ozJJpIJkqBi24SQorTJopuXaZJo7yAsQw3gfQwDB1xsVADj+5yKvMgEyAEBv8SlcVQVE7FhnHSAM0DIKQfYAYcWTJEq4pSHtBhI3D22oUGjQ3mmV4s84Sy1HLsegXS0OKkQid++8sty6XLgvqmaLxvx+AgRjzHXUXOAMdt9EA/W3iyny08mUojezI8QMSOTL2naJDPqDNR+qZpXgX0HcNt2kLaIQcDiTvJ0+iOUJSJlk/LVAgWBxjaRV5gCkdASskNVcei/WzgLtJi+QoToSDGFP6GZDQrAF4jwBRujwx78p5gZF3sCc1jO6izFVt33VSoOV0lFFvg/LN4T90CjOFXlUlx0o1qhkGhzwaFPO+P+i1tJkl+GBdLIgNllAhFgYfKaZGzQjiUNycdyF2MGsocpButGzlrYABn0hh0w6H5ckRz2fmo2ighW9PiA+zVDJG6xGs4cXebmuyHh4RSaWeP+cbkER3tqEDvMP4zKXfsMkFzSk1Xjq2F2KZW7ix9lzro8xaVCmT+dj27UVmiPJZ04JYVwoGS2qFUbKAFJHUME3LeGAIjux90nlKsGNGgtoFJVaoBrjrpcBZiCQG2crQlKwtxB2jVkGFP2tWu/EahRkb1M8JLQotGXt9T74E0Y1f9erwAYBoekGAPxlpdjDnytj7weDK87KZqwDAiGyJjIzBxKULmi6dlxp6ZxOqV9bNuNibCYcNUUzGTseDfUWpW8g95QVTKFs+mzSrEsVYqNBEOq1BNZVahkXJQhd/09VepU9LLLnSJU2aRi0l81dKPDZEAdoa58PRkg1VtWc+2lfwuAwkbw55h1WAZxEGKYZY+lQlc9xM5mrCFOQmHamnCwEu5VXrssd4syYWmqiFrNAx4/CA1PY0rdfk+nBh+/pcP3Fz/IO6wgp5IsHvLweJ2AQP/d356Qb1RGcyTrsq8pUjHVbw1FokvKA4/mcJPhM9gMfSEBlt4BnM23qrewySD2cEbuHiHzp6OJj/AlW4cwRsAMX8dixK3NnybK871cy4IBWhjKjmdDr5zwcX9G7082F9FWEz2JcZ1AtDhsMNGxQIFGRaE3kcn9D72hWHDV/jqeqF9DTzHZuQxxT+MO4U35cIm7eqpgluVfvoQR020J79/rL9efmiz9HC6RlWNmp9uzXm3+Lj6ff314rRZmtc/fX9tmnL/448vLy/Ll9WyqC4/Bp7n4ZTfO18T9PKvRfvT99jn7Jzd9x9Xf/i4+n0ZNVfnnKTpT99/DFbn8/l7J/7p+182y3CzXm7D1F0tw2dntdz4AbaS1Q7/Hf7Jc9bLYOMEy+ft2tkug9DZOcHSf179/fsfKWOc68fVHz482WoJO/UGVVmSR82Ye3trjVjl9V9QL2tnLdZL3VTFFyTXjOcE1/VsJXPXPNfyoXtoJub8pnoeyJ9MYyf5CtHZwKnf1Uu8IYt/sCm6a8ddC07ilFSnFDnVT9+vvpedhdEOhwr7DY2Q9pZDuxPJljUZAIDnrgwh8pcMKRp+OUSGgOBnT/qCfGMnEoLOnZ5col4kcLw/EU/y98xzsDtfXde663bY/gRactpt/7grW8f3ytbp+nqHjjOnAFfd+AjP9aIqyk9IGB6pgcrvB7R0ojwdtvOO8fl8sHvJxA92C3/3bLAmyn+/x2O0r1F660bXrLLBLfYKj1+zW9okZYo+K4+S/oqHPp/JPI98/vTB//D5icMr0uND0r4G8BCiKrjt5kB14M2SkxKjtozy+K7PtCiRW2dWWBDb5Ctvyui2724VhGgbflTzSS82sN20bPxAyIes7oxuDpziSkzzk35dbmhZYlImew+YC1ssScKtZsqrP/Z5gU/qsSwhPto0UhR7zIQFPmmUXz6h/GlApG5O869V8VKjDw8gS3gaxff1e9opoCmdjFWnYjjKM229wKiCseJ1ayPdCrQyXWRys5LOK6JaD2PLJAx8Gik7tl8qAztUJYxS8gu663vZ2Qan4V3n79KFEQnUZ7eg2P2e51enCcH7rrfs+A7okpwHlp2EfCv+9TszpiIT9m5x6/2LpkVYfwaQQ9z3xgx65OJR4RgYtTrCRzif+Q1fjjOaomp1M866CudS1ROvNvrVT8mOJ+JnJ0aRS5hHdctz3HG4TRVJ54F5DYuHBsQGLT87Z0Tbhk6PqwYAGqvYvgz2909tbDb+bY6lDWtq1JKUBJOtSEj/z2g4tbXH0s7dqS+M0pB/Zhv7BuZUW9tRPdeA6ne3HJt7MHgEzVVeiBNEOydp6qbFiwwkgQY6YoeE060s+2MHbBUvLNtR44d4Gx5BB7bHyTDPP8YY32B871AwZqN59HXw4JAycFU3NCnXAhB+9LaXwZN9pJI4Kd+i2v0eeleWEy1hDIISNNGxlvfzi2N5vrbFKR3yRc6iysWje8FkMlI2bW4EtBp12ZyP9gxbH/g8Ss9NVI8SQxUlz3vpPMbp/oVLO6DCuZfm6OokJ0D7/KAiLOXjrBYzUrn1O92/BBvrM5BPyqvHTeacqMC8yyRNdUOA6lCh7I5CCnH0vqWOl9VuAUyN3aRgs/Jef22TIE1DTxYlKFYSuseoTnDByY9LVbzsfYhHEx35qaSfyY8yEvZf0KYp0bB6VY7/5tHXY1S94TiF4WFysgXSPaLmBaHc5GyOUfXzEqeIkhxVCz3IPae3JB50h1Nl4Rm7xyoSdhtLoJ8MMfoBjDH60oPu/faWkV2E5qPvsmiCl+nDRhwxJoT7D+3A24xuhHEXWpsMWHva6/liIsMlO3UTNcmJXZwjZSVt8zXXD1g5oWBiLr+SSWxfZMgmNjFogz8XhOwkrLS7tTSQGdozanWfwWC/pfsyQSjFSniohZ1w0sEL6dQH2pXEbnIq8sE1uGUozF6WwAUlbMUM3GsibyP5EdeZQ/7qFqT4iO1TFrVsWBxuw+Xzrmyf7lxYurBBtrxqzgaMZG5nxLr7vLubnsLtBsyYWh65j6MqXhy2M3zoCLjKwRGbt9Kiq+JlOIGx8XEEeCy5ocED2wPlljdX872PVzyjLl/XuEWf9y9JVhZVE+XNQWjz9Ny8kRNv5lIfChjYdrOFDSyLB4opRc42sO0GzvitBpbFEw1MTjDZwNTkbzSwyZofMzBBvjcamMDJ1sCen33YwNLLQDGlyNkG9vwcgBm/1cDSy0QDkxNMNjA1+RsNbLLmxwxMkO+NBiZwsjUw339+hi2sTQfKKUXOtjA/8Dww57eaWJtONDE5wWQTU5O/0cQmq37MxAT53mhiAifYxGT6N1bktFp8SxW+Z/2ZK29qozmMVOw71epwlfLIlO4LEyehi4E4ZToCUYi3sokXjj4/GTKVK0dPGFolHJRMpjRJuLXKSAXxRA6rQQ4UoekBKBthRRhrjLS+Fi9DhCD8ZVVF3ISgypFRQumK2RF2dHb5pr2w0nbJFf7/9xa7LIGN2Uxuh/1/GT59z+Jot/bT90EXgGfBp6j86XsidRecJQ2q0iRLmp++99nuzLWzvQbBL2vHD+m/weoaBMBmW1hPqG2mNAhyHjgymACNHGwmjMSiBcdR9cXgNfQoJU+AQH1LAc7H6CiCMFzw/0TtmFMPiTTiLKTMtla5gS5D4hMM8jE6joEsFb8xQCm5DZ3OCJrDAgOuQqkewGFIFL5BFf+sXgML7fR//Zf5DllZiuuwaiKK/wDihtoN4D3Y/umoiq1WIDQQu59VeIeXoorpqOlYoeiLi39bXoreLUyO3YkeGC9Fx2X4+aosk3vqLWqEakmwdXKsVzzw6wjh7FJb4UrHt61havn2B831bPu4oRvY5JyBk8di3u6xiF+VdTGOpvsSYZM0KVJWffllfoSgvh0lGrpxbwXe7sF5orYRSwVTjS50d1Q/9J/STSVySdh9ut2iAT9kEoD3kJiOvhC781ZPB9PiuWqfUu6QCbHqIZuV2UqG6/hl++QAQZ7jSQx/EKzF1mA7DZ+LojFrxFYD8hXWhuLTrABT7jYKe1Bx9SCp9HQbg3yFzXIDVagrXzdDz95yUuU5CzkLshQ9nIfEjaVOsouLbTeNXu03eLP5JtwSk+wibm8asx5BjqYogZSq69JZGN3YYG60NECGkNcyZwp4MGO2MRLexDF3TwK1Qzs52Uj8sGwHFpH6rGQ8haApyj1KoXJjJwnR89dk3vu4iX80da/ani/VbUnuD2fJ8iROwV5F7F6MmTqimelKApiLZYa7AYH6B0kgflBAOI4ApDF12pNuVRli6ojeYmFDypvkwE4aCy7Uo1pnyFrlxHLq/nrqXSdmjmOK0ygBvU3Ozag1MDdQaWN5Fnn6CvZxkjeHU4zpRKMc0cmE4ehwPka9gRKNG9u00aqYoXYvD3zvlCDYEyD2DC5jmpjP0ljd81n2tfDubAVzU1oB7ULqOz8VQn+7p+KWN/vVQfmpUF2istuwAwQVVXmN8nrvH16SuHip976cqdKhGs6MPsBE8OwmOp2KKk6K3NG0Vpzd5rVEot540N3wNlqvKgu+juWcAeAmMTIJM+MGbzUfsdDzrt+uUBSfqlt2tNld3U1O9KG9T7d4jT2+Jp9eVLxMLwyZOP2gBtyh5aaxRMMvNkGLWvIu424L1o8fLDIjM+UuS3jGrKRRthbz/eFldElykkyuGWVVTFM5qNkyuiC2ijdyz5m8JxWar/llq5xiDcKxN1INJ3X5nu9OPOUVleAw/ICqlZEpN0X1ecl3QgeWdyWohzF7ftO2DJJ0Kj7gCDUFDrCHhxYDPXifnTjG6nMbHpwMuSwtB2bQIvf+ULjF7nGl4viW8p4/V6qYw+gTtPyoEX09zHrjvtgQyaYSoSmpiI3NxtdlCHMcsgRT3a9Gqn7F6wXObaIhALnpBFJ2dQaqa9KlqDDDOdoKxhqKUfxZzWa01dDeK4ovhq5Jug1EuoJ5q17BbHflsrLF+BjVCHNhQtAXAJXtDscmd5iMesfBT6kwBgSjU3eJbLRNIpteL/wonNerwi2rJIuqV2klRIr59Vqh8+fuES4gSnti3vrhuU1wOvHsanQq8lgWBUjEu2slESSlGjlXznAdHjdBl+XtdEJ1PSxlsIu261BJAsooRc2V0EdbtFrz7JL8XAyL52+j4LgT6SHZhPDZgvnbaHfkGb1EVZ7kl7v8HiPUN5x8b6ukgiSUoyQhxccex+WMV8/I83iOcZRf5OICKU6rsK9hmgISUYqZq8ZjHPirTjyyG2JcieztSCENJJ8Y8RYFRshDgjqqkXNr9G4wkR5WXhc+2wLjwA/Wj+XfbtmxaKoi7/rFwDCzMpxVh2dSpA82A8N6rmucK+mLBJnsNuTps+AUVdCVTlaLfX7fYcIHfxh/Mh/vWy07N8YjSaes9JU8Lk7qLKnr5JgipWhrCjWoVM7ylBa16ebcfuXIUD5QQKV/87y1twuB6j2dUKgNSY+7OMIdosTKuUovnjDS5/Mp1klFLXUSBNsw4IRar7fareI1cFzrOxSgFQrVMfMm3sVHjRks4ml3Op7OOjEgZOAFq2DTkcpdnh+G22ANOYE1ivvLkHiuK7Q5HRVWsIBHPz4fNVJIh8cA+StOKPZ33ilcb4B17O9iH53Ovlq/CIXoKPKBBYuOcYy9m0AHSbUJTqtOKqWz24WbtQcp7Xw+r06xItj5jNAxUljBsp3PaBf5KikgXrhanb1OPLmP2wb+CazS8y7ealV6Dk9ClVJOBuH8o3fcKpSAbOtnP/C3vVMROridv/N3ASQawn9U0eJzfEYSI1gydEKn80YmBATb7PCfvgB9v+YffRRADZW0yWe1FWxOu1Mk8jE0gefj8YgkOsjS1l7ohY/fcjD5C3o9V1GGaqesikuF6to9RpVbN1VSovp+rorsDt2P7dPbyZoCjPUc7/H47TfkveQcZcRNvGVGfUBcmL9q91LaQJ5iGWzOJ8Mvbx7Uccj013cY9CJcvEFGDs5yU8tSMk3H+l5CPJmMKveCi4jy5tM6jNFlAexUDJ+cIPy4EPp27XfofTSkNMdsFR7K7yftwnW/P3YvlTDKkyxqUNwtodAAYkW1Q4vpJPk5yZMGgWZ4mJzisSSDNvMDTuLBEEIq7h57CJuO3n7M/aFuYXIjklrcTSJfhKG/YW/iwQfUhlhpWC0yt3+c3sBZRtmN0xR+jabCxR43Hxrj0js97MBxfQvXt9sIObDXUduR9w6ryVpBQJNQX1QH7UBj1oHDOj/r24AJ6KTyZfajLU3MQLIF1uf0Vl+1LYPdAmO3NU3YXaPPu1R+c/bPgnzm7IeF3IftpIfPbwzpJ7qUkVSSqzGKxOdR05gra3omG6F5KjaCA/X87CdmfA5m5DBRjaPpJEUaxeKzvansrVTJc5VUSQOBHC2nj3ymaEg/VY3DqSQlGkXiM9JpzK1UyPOUVEgD9fysprh8Ngslnqi8oSRyOzYJw6fMEzjbNWKWodyISaCemf0cnE63DeknKm8klaS/IZHItH4acysV8jwlFdJAPT9bnIBBAnDyiQocTiTpzywQQx4m8bZSH89SUh8N1LOzhDIYagGmnqi8wTSy7ZnE4djIFNZ2lsdylC2PBEI1ZQG2cFwFSjzZ6sxJ5N7CJAwHbyZwtusqWIZyV0ECHwwypxeXkfGrtCMiVJ8T1teyu4GQR0f83UYcPDfy6Fsr/K2HZcgynLj5xiINrxYbUmUo6cFT1k7obfg43pqmyPn6Aps7jty3311LbLjt/LHMijhK3aJE+V0BqsQ4h353JG7L0awu5JVdjUAJu7nvOWlRPHJsppuveaGnwWXCDf9UnjiJ0uICzK4p1EA267AXPtiNE/rOHsZreY5i5Mh8BTiLfJ6LKnOWK3a9bXFrDqMUC65tAwMtmvJJowZ98hZuEH58OgzEzblc11TchQwn6pfo0oT0tlNJT8OF8Ewl8J7kenQp4oji0XfIhedU6bM5nvfRcZ1PdNvhb5zgycRa288pvb7BmX29KtyEq/Q4YxYy74yt+GaGbJJDG8yUE7b9/YwjR2yDJ73pYGZxVZRzm+caGiZ7nsafGJr4/pESjc3pLjpkGs8OelrgmZa3pPr6IUFhK6mMsg9ulYO3tslyO4prFtbl9y7BjcW/BWcJHtXVXszvlFjEr4D9GY4EC1KyQ6NjzQy8XQjlMahU+Qhph4SKGf6sn1q4yxfrh5qQP2vnGu7K9fximvpUFWl6jCo3Q1F9M75b6z4/Pz+XLWuHoVd26zTku+t4KL+BLRGSHxTuy/S87mDfnr+BJ9az6vFMHo2ntfJpoBcDOdSZIOwKCzt0bx1Nk4oF3NE0y6Yo0iYpB96Z9r2tp76GzR/dIkO5c5Ql6esej0dS5NavdYOyxb+mSf7ll+j0F/Lz34q8WXz4C7oUyPnvf/yw+PfiWDTF4sN/Q+lX1CSnyPkzuqEPi99VSZQu6iiv3RpVyXnx4XeYqfN77J6cP2TF35IPPR894C+v2bFIPyw+/LloCikVG4aynfJVFqXSOHStjkOXobiqga1b/E0dFzjMEwetfUDfgZKwFDW4y8CeDjdDJhC5rIHc0yCFqFTSeh4JottGSULiMvRtteA9EIJTZ2agePPnLsJZRlVVvABmAj2avNwJz3Ms6fYamdHAs9TipbcjTz7Q6iQO67E81i7Lw8VK+LV1yzQ6oQzlzf/6qSnKzwuRpME9J1+0WbNnsUZZMOlVTlw7PQRuy6l/FAHk2B8lIb26/NIFkZrJftDX7klfPigHccCyWkhQPyNxWOVZsIFUw97PpMphIxBB+M5CdhMzAbUmZtbpTVlC0TWn6I8ODKw1SCtcViE7dznNuBgjSIk0imuRrdVMYAYqS2IqvA8sL/OxW2REVSnre9aawrUv6wmHTLQ0wgTSEY7gGuJVPtPQxDxA1Ql5dYqTl+ZEKwOVR8amouo47yTPyasyvJcmt4IewKMTg3s+wJG9aQ9KURL8wrTNUZs5bPThQCcvHlX9f6OC/6NHBe8/d4U2KXOzmzawEJ/9Wgo7LLD/gNiy1z0XWrBx9CHn+oaxCMtxaCzCSfBYRDn+HHJHNcxG9IUCN2U8QuYTDA35gd7p8xvH9Z/sM+j0aJ9A8Jy6ZBA/YNQj+9Pe+bHu9H0kMfR9/UhKsubwjVrTdHDvwQxgEEcPQA3lJwziOBEdxEkTcwt70odxEj9pGGeyqINQVcDzfLTtj9aeMtazMT3z8BAqBMQTHD4aDdDODKdKBY4mxCHpNFMc1SOgkzt/UhgcEY+bozgi5lRsRCzcTWdjj8CQWGYoDolnujh1pGxjagOja1A+iKtp+C2PuntLm1iMcZGgaaU0pJ9maeN6hFRyZ5AjPKewtjWH9+78ro6h8sOkw4Pf0PtoHo3I18+xobk6atAB6/MW/xkpYD9p4jRk0iTjpxb2oc2bRHbyvOnbenZ5cmXT2ozTMaAIEEdotgZ49SmtbZpIMBAhzACntbQxDerqYFkL7UycfpJWJjeK+9AlIN0wSVjW1067QXMIYu8DCzhH/Gf4WsSV9a2IK/F2QqXJQwfdey8Rv8LFlzaOkwuMiluNUn31po9js3nT4jZZPNTW6fvEw9vO6avT+pKPwJuv6uLKOEcn5H5N6uSYpEnzyhfkB6J46hJVdYnIthDMluARWpAit5ujtlkoYWWFviph4POLhjX5TW2MgNboN/Wsd2vfUgrgZWUrdqbOB0qvBOE2ArFUguiEYGCV/398ghf5cfjjt/WtLIuqqZ1PnzQebN5bVqhG1VfkruInp6icT0MEoKK/UclWMfWtYPG6yMeDVSLEXhUDSzusTNz8DPokUd9Epe9XgFVMxBxSWxdv0pyp/oYV5w5ozv0Hq25OCVYxFXNIda6ou4493c4je/9ufU7wfG58Y7ii7BHdsipKVDWve5ZqmLdFk4NSmVrgcDLuIHl5fE02mwoYoKReQFjOfF/2is83qdNCd3Z6+qd01P9v06R1x9Ax5q/ZKxLy4KGuvN+HNXXLjjysCz8Or/tIG2MhubttrWAk2chqKJoxJYm0uw+lv2JP3GIAa1K4S1qXlE+nDNHktRODqKOv8wbCZiLyPenp3aFM3/T8yvhTK845SdOfvv8YrM7n8/fyey07Zyc+xRL/9P0v4TIIHS911w794y9DF/8X0P8c9q/Lwv8OvKFiVv4/WVmD5ZaU1V+GuJyOUD7yzcPXLvkzWNYkj5NT1BRVDbR2Zd+lj+1HXUANZSdgaPHwGW1+6/xH5ZL5j/rb5IDATpqYtht6fLsh31LWN4JVf8V9pQaQ7PFv0t5xAfOGbM4r24O8697wlIX2xA4s9ghQ54qKHrl+uEOvcBJxW7ApZ4qi6Bl3p7q/Ud68EzOcUO4bX1SS4/kma8TWwS+T6kTFgf2SvvR4fCDsOXDFhENdz2NJOzN+reDdcN1g/xIjT9EUpUrcFKVOR99EV0lpqE7N1hxUKUgoIAMuDpxEiDKkgwrAwsUUx0t3ENp0YFwgjwR61vVKQbSrZudINFI9nHbQplsPFTn708amGw9VSbsUoqx9oCqtSg7FmCSm9x+qErNDvaa7DzV5Kb0kLQvSZJVI9XCTnPQWREVOcnLWdAOiKiQmFiUkv1XxBCIl0CgYuQVREYyfTTVdf6jKxuhF8XiQKqFMqoeb5KS3ICpysgOgphsQVTEpuSglC1GFlAi1YJOI9CZERUR6yNJ0Q4kqIaEWBaQBqnwimRpqVCC5BVFTYPUFoKU3IOrqq77Iyqu+AKrriJRAowWSWxBVC7wmjaGzUyiF3Tc6vRApJSPrBXfTJeQ6qfKih1USikNIt3fYJINe6rBKSFYDxdtBbBJ5XAkeXOiOgN4LYipmT8bGvMaC9ZR8FmwoSk9IR1MAWdeDAjerAORCRyYl0DqxLgHvRyRyrQ/h5NSdywdhVVfOaTsPq1ytp3hXTs4dnXzBourkOvWJlmfyNz3r6otCqzX/TmraKhWZJV2T1ofgh3YAuvGncoTXuoevLoK4S21wNN34hUZQHrZP6xjzGSpzn43YvG01NSmDU1KdUqRUXOh9hGg99dkTkeiUoqg6Jy2fLCm7KHEsHntfpTlP7OKJqrQSK/KMXTqJUrAaiITOs0BQRyaX6QCCJjqmfY7kF0DgVsWLTIRDIMITSlOFEgfJpHgCbniuXiijRCWECcTmY26xW2dj6q4zG413VNZKr7NxvdfZuOo5jY32O1qrCqizsTroS21RDUA9bDc7Vg/ZqNlnVpafTTb+zML+M4smkE1oBdmkhpCNtoVsSnMYOBEZu+llrB7Si009dFTW9ZBexushvYzXA6exqYeO1qoe0stYPfSlnlcPPjnZQiqiTccqok1tKqKjsq6INh2viDYdrwhOY1MRHa1VRbTpWEX0pZ5QEWWV5A3WPfkYUz8lsqgBkdC6Emii0XqgZKNVIZDZ1IZIblUhNMFInUh6sKmWJcqOeOiK6rLI6+Qr9NwKuAGV3D/RXR+jbSZT2RouzxAHZWoSRwsh65ULnZAEAOEJua8ZiCiOf0OnBoj4msSoGF9KlQ6Uyuh6997x3tOL5Ab+8fW5X1EQoO91sNyFW38d7DYfgYT+xpQw3CyDEEqyPr6uwBRbkNw/vvogOXk4cUkucMB2rdxKohg2iaU3laiUNFQjrooXt0JfUUUub1J58yhDHqaUcqyW+KWK2APF3UuDGg29sFqgogEgL1mMjqcx/3OSpvLz+xrJBRfeu3ff8qynJ/EFEl8jqa9Vkn/hfOgvgBMj8yUyiZuyVEjvT7mDt3yQqKG0KI/hlCiPh9LR5R4tKQ0eSsgudNFSSte9DDGIyFTUkJ5G6is0ZHMFUxR8/4wpDVaQlgKZ82CK0fd0mBJ0S2ViEvM6GS9JhZrTVUrDwvQksp1IYYMKEG0ESAUqQbEPOZlJEaptyKmMliEnZnYBpTVZRa8YUZtdWpM+a5SeyZ78u5vV7qVKYuI46Zqf7EAOfYq96loEZmLNENqhaiEp+jrp6cEKIdSsNgBx1SoRBTZVF2GpmC1JYLZaVkqqZkAMTdeiHEBFkJsFKTJGLxnEnzoBRQGFawh1EjLqpRTqmJcPPXBFNMmpH4rQ3yApH6jpQzeQnA9q9GEOSE7u9lKu+jJInJy+CJdK8R1wNFxQs1AmOeaxJNzpDSlDd4tpFwOsPJ6W34EhJx+/lGzlSZsYDaWgGxeVAjw93Zf0S5ZcTqoWmxWplyDwHo9lXblFnr4CQ1A22Ow3x/jC/Qz6hYfkqDweDrEDPt4T+BxHN1RlGbtkNQ1PQdi7BQsghr5fq5imeHEik5B8d4KRgx4popLRDT/azQGPJb2pwK2zu/QW7tJnN1DQf8STS942fBJtiKZRknevR8vPG0Ap3fQiJybJVlpaMFvatoXkagN/cYOQPWcRhB/lmNC78zvAlJgtT7NV0/ieJ7yOIceR/qKvFjHyisXgWw1lnlcsR3elmRK17VJt1VRYEmEaJEcSUQSzEGMzWor+Lg81eXbtCAwZZK535/cxSOGN6y2W2WsXra8sZhUhaXsSYFUxO6p8oAXFLFVZ6auJmetzSfXVkaxxfZKNLx1Z1ukqQtf2dOKNdorgCkd+z4NOmqpMhZv15CIEd/FqVKUEAckv0A5dKwUISF4BcKRUkV/hJ95ToYivsOzvH5ClX3HpfV34FclsJQqvUVWEqu2pqu5MqiK6wk14cFCRXGFIV9Q1wded4JDe1ySztSQ6pPg1yWutCA9pXuHIxYdUrzClBQB0H/IirPQChCS7UCyARlURqranYvtCdeEVbkx4jTBVGdJ9pQpZ6Xr9hVFSBHEw5Wsfr3uYkniYshVoABdTHjVOkI8pU42Z7mRK11devVZk9klOviQzQEjcTNkKhCY/Ux41nkZHU6YaW4OnKd1APhOrFCMgWQZyMYBSBCS7QC0FUAiVo8nblKnGFHY3pbuS7nJVSrAi+a1kwE0vwIrktVIKoBEeNX4Gl1OmGkvQ55TuupceqoE1yW8tyw9VwZpkt1ZLANWBytPod8pUY2twPKUbduXQ2jbxPOVrTwK6npK4nrIVyGDfUx41fgbnU6YaS9D7ZHT4xDynNnxqSDRxdwIdKYRGW3HaVqKt4IHZEebMiqORpzBzUiaVmOxTzoq8IMP/u3hx21/+7ZciL9x/R5dbGlWLX1CeFotfijw6FYvfF3ldpFG9+PCn5IjoCR8Hk39YfPh9casSVDl/Ri8fFh1rlhXD7u7C9nEWpEnFkF99uqRRNtUtP0UNUi+9p5vUu0CUpklZJzUwA2OMCKqg3O+m5UaRBYFKgxdIHANetH3yAqF5twYFgTJbpL/OpoH9lPMcvL/LaSbkX2dWqD/Zq2IH/DOOU7H/OrOB/+vMZgWAU40sAmTW6wDZnKWA7E2rAXU2e0EA28TcNYE6e/uyQJ29aWUgm7U4wPQ1ZX2g15P9EgHWz6xVgmzmQkE2e61A0oj9coGqFdsVA8FyZi0a9FYza91A1a/d0kGdvfPqQTZjAUGqKJs1hL6K3nMZQTdtq5WE7P0XE+psfD2hzmyWFPgeS3hVIcPxRoQMx5ExnkAE4mSMsJUIYbQM5GnAzEC2EHJWj4FnmIDnOg6hMepWoh4A0kDuQ3AamIERVKtHcDUcz7MfRdcYcSsRmzE2kPcA0gayN+Ft9TDkhqN53mPAG6NtJVoj/AZyNoNwIHMDFFePoXGYgOc9jskx6laiHkDmQO5D+ByYgRGlq4eBOhzNcx+D6xhtK9EaQTuQsxm6A5kbADziXEwYHnVB5atEBSJ5jLKVKWE8D+ZqQPVgxhC2R7zJILxHHU/5KpGaQT5G3srkA1AfzH8I8IOzMMJ+xK0MIX/UAZWvEqUR/2PUrUxtRgFh7gNYIJyBCREk/mUAFKSOqHyVCE3QICNuZWIjQAjzNsOEMHsDWEicyyBeSP1Q+SqRmlFDRt7K5APYIcx/CEGEszDiiMTTDECJ1CWVrxKhCVBkxK1MbIQVYd5mcBFmb4AY61GUkVFw/2yBNfYpWjWFEXEcyMWMOw5kZEYf+eh7DHfrRuCj0Fs/XxlC3wYO6ZD5UBbbwm9ZPA1+o5znwG9dTjPhtyy2gt/IESU7+I1xnAq/ZbEN/JbFNvAbpxqG37LYFn7rKSfAbzjRG+C3LJ4Nv2GbmAu/ZfHb4bcsfgv81ultGvzG9DUFfuv1ZA+/Yf3Mgd9IqWbAb4o2psBvkkbs4TdVK7bwm2A5s+C33mrmwG+afu3gN5zpe8JvSnXZwW9SRdnAb30VvSf8ppu2DfwmKP7d4LcsHoffstgGfuNHa03wWxab4TccR0Y7AhEIvzHCViKE4TeQpwF+A9lC8FsWj8BvmIDnOg6/MepWoh6A30DuQ/AbmIERfsviYfgNx/PsR+E3RtxKxGb4DeQ9AL+B7E3wWxYPwm84muc9Br8x2laiNcJvIGcz/AYyN8BvWTwCv2ECnvc4/MaoW4l6AH4DuQ/Bb2AGRvgtiwfhNxzNcx+D3xhtK9Ea4TeQsxl+A5kb4DfiXEzwG3VB5atEBcJvjLKVKWH4DeZqgN9gxhD8RrzJIPxGHU/5KpGa4TdG3srkA/AbzH8IfoOzMMJvxK0MwW/UAZWvEqURfmPUrUxtht9g7gPwG5yBCX4j/mUAfqOOqHyVCE3wGyNuZWIj/AbzNsNvMHsD/EacyyD8Rv1Q+SqRmuE3Rt7K5APwG8x/CH6DszDCb8TTDMBv1CWVrxKhCX5jxK1MbITfYN5m+A1mb4Df+AzBDL8xCu6fLeC3PkWrpjDCbwO5mOG3gYwGNv/FdvBbNwIfhd/6+cpE+I3fzULmQ+nFFn5LL9PgN8p5DvzW5TQTfksvVvAbuZnGDn5jHKfCb+nFBn5LLzbwG6caht/Siy381lNOgN9wojfAb+llNvyGbWIu/JZe3g6/pZe3wG+d3qbBb0xfU+C3Xk/28BvWzxz4jZRqBvymaGMK/CZpxB5+U7ViC78JljMLfuutZg78punXDn7Dmb4n/KZUlx38JlWUDfzWV9F7wm+6advAb4Li3+8o/WUcfksvNvAbv1HNBL+lFzP8huPIaEcgAuE3RthKhDD8BvI0wG8gWwh+Sy8j8Bsm4LmOw2+MupWoB+A3kPsQ/AZmYITf0ssw/Ibjefaj8BsjbiViM/wG8h6A30D2JvgtvQzCbzia5z0GvzHaVqI1wm8gZzP8BjI3wG/pZQR+wwQ873H4jVG3EvUA/AZyH4LfwAyM8Ft6GYTfcDTPfQx+Y7StRGuE30DOZvgNZG6A34hzMcFv1AWVrxIVCL8xylamhOE3mKsBfoMZQ/Ab8SaD8Bt1POWrRGqG3xh5K5MPwG8w/yH4Dc7CCL8RtzIEv1EHVL5KlEb4jVG3MrUZfoO5D8BvcAYm+I34lwH4jTqi8lUiNMFvjLiViY3wG8zbDL/B7A3wG3Eug/Ab9UPlq0Rqht8YeSuTD8BvMP8h+A3Owgi/EU8zAL9Rl1S+SoQm+I0RtzKxEX6DeZvhN5i9AX7jMwQz/MYouH+2gN/6FK2awgi/DeRiht8GMjLDb3z0PQa/dSPwUfitn69MhN+6K3nJhKhNbfG3Np2Gv1HOc/C3LqeZ+FubWuFv5EJiO/yNcZyKv7WpDf7Wpjb4G6caxt/a1BZ/6ykn4G840Rvwtzadjb9hm5iLv7Xp2/G3Nn0L/tbpbRr+xvQ1BX/r9WSPv2H9zMHfSKlm4G+KNqbgb5JG7PE3VSu2+JtgObPwt95q5uBvmn7t8Lc2fV/8TakuO/xNqigb/K2vovfE33TTtsHfBMW/G/7WpuP4G+4yx/E3fpG+CX9rUzP+1qYMKxOIQPyt5beriYQw/gbyNOBvIFsIf2vTEfytTRlCJlCa8beWX7cmUg/gbyD3IfwNzMCIv7XpMP7WpgwjEwiN+FvL72ITic34G8h7AH8D2ZvwtzYdxN/alKFkAp0Jf2v5RW0irRF/Azmb8TeQuQF/a9MR/K1NGUImUJrxt5bf3yZSD+BvIPch/A3MwIi/tekg/tamDCUT6Ez4W8uvdxNpjfgbyNmMv4HMDfgbcS4m/I26oPJVogLxt5bf/iZRwvgbzNWAv8GMIfyNeJNB/I06nvJVIjXjby2/Dk4iH8DfYP5D+BuchRF/I25lCH+jDqh8lSiN+FvL74qTqM34G8x9AH+DMzDhb8S/DOBv1BGVrxKhCX9r+UVyErERf4N5m/E3mL0BfyPOZRB/o36ofJVIzfhby++Xk8gH8DeY/xD+BmdhxN+IpxnA36hLKl8lQhP+1vLr5yRiI/4G8zbjbzB7A/7GZwhm/K1Ne2RMpjbhb61wH52Swoi/DeRixt8GMjLjb3z0PYa/dSPwUfytn68M4m8MrCteUHWKanRnN9lFeX0uqmzfRWj8b2UJJ+kitCSnqEyaKE3+rqXpY6TpRJE37gu545k9LCqE7Ffym8wiMb0+XKJem6mPRRpLtFuAloh3omR185qiPQ3RCkkfKoVfKCUE/OlY84vrIln36rEUSB80Nj6dTo8fd2/Oml9MlwnlvNQX0I3PnlNq9mCt+bVzkUzJSXrB3PhsOaElL92aXyvvaOQchHfIjY+P09pjj+Oa3xwXyeRM5HfEjY+HE1r2qq75zXCBSs5Fegnc+Pw3bdWkzZhf/e6J5CzE17yNT3gzYaovd/PL3R2NWoTuTW7jQ9yE8FjEnfUGfhAGzxpJdmtQbLRwxiaNTl/c0GNk4r398q39fQNWqIMwXPD/oDTXJKa3lu69Hz0nOmhPgNM7QIVXAA5DD4YLLzGwdxLu5N8kTZpX/nSCKESSA3T09lGBTHp17zcL9kjuonvnS5VRQJDMbxhE+7xoPi2PTf5EGcToVNCrWPe3PEZVmuToER2P1a9N0qToM3+bt3vtzfn0wYmapvpE4p+cD08fHmWFpCtXywq5ysoHeTPuf9+KBi0wtf6iehQfw2N8KKMLco8Vir64SV4nMdpHX4skfjRXFMXKQ3s4CFUurpfykWSXRVPdTemvweK6WpT3oiqvUV7vV4eXJC5e6v2KRokJSYlZut/i8Hud/B3to9VjidUQJTmqFsTalW3oYiXn0ddjVEkPJD6Wxyi+QIX3PO+xpM8U9o9mp1FZoz3/kKwYUzpNvOBf1/EX8KnKKHcU94mFoKvVQ/c0leBLkvyKqkSKcRqsnh/I3wspPJZ/XpWfKBLk6N4vJzLwYi8JFU8gy3AAEz6Wl5ubJVVVVMbHcA46xNm97/L8/Cy4skNRRifcYpe7g5vV7jlJsbl8KKviksT7////+GMWXdB/8NHS8pfkVBV1cW6Wv0vLa/Tp/6LJf9p5Tx8OLHFEYoo+5lAWCR78uegrypuamc/lRn0XGZm6WCzZ5i4395bXKEUnakv8FZtbTV61x+Gqq3Cz4u/D8fVQtDmKSEO8ZNLcO5UFb1JZYFRZ4D3xBiS87GhqS4cBWJm3KG6JXbvaf3cO8B/hdXnWN4hvqLOakrh07/GTehPT0LmMlCTup8Fe2facuhFduAm23kG6dDu55MmXaFFHee3WqErONJp4Lcyle2toV7aO56zL9mCaBnQZVnLRz2elnL2PkF7WCcKng1jacbKKv4hkoOsloqMQh/7+618TbDQO9vvDFHV16loCM55LFb3WpyhFn7ynAxBmzrMbvazRKT6tHzyC+CQ3IjsKam2+15GRAXG/aNOF51EmWa6Ebyg9i5DEYT0KR1xJ9XpO2BkO00HH+qNkOB/+co0q5PwHOl3ZRezd1esGC6KVGniiRAdtyjpmXXrdWdUV1gxQXTSYuZqkyN34xkY0y7AWw8uqKFHVvO4pi4WckUjZJBku7PmW0y0iCJS9f05J1bdTf71wnYfCs1/4W35Fl3c7ZDOHsxIZxUKt6W/UjrabGTW93KHsQN4a5s9LkYfKtFeFgQrvdLcn7cPBqv+KqiY5RSkjzZI4TgU1xs4yixpUJVHqJifcbGTV9M1EEDHwBBXx5sbe5Fr1zxqHZYtbgeMd1KYIX+Qv8uvf1irbg9H/i4MkuWOooji51fugbA/dnN87QG9aHyRIays46qBsnYDK32u2l8VZBmG9YJoOwlopAZuuSbI/4z9coHO0efb0bq9Ln0Z1456uSRori7UKoVaDgtdYBihTyF03RilqkDydRN56tV4BwpwTlMZuGh1RepdGdHOcGK5MBTY6wI9F44ojbk5s1oIsrltnUZreZQ/ZUZI9YOZhg2AdQEfP5jRQ1fXDDuKERUZCFKknOE4f1ptciRKtdOQ8lrsu7f1Cc7loPylANnajmZHupGOObbDbq0Dbv+NB/qsohcrtkosARhTiP6IBBX2Cqnhx3biKLhcy4jzdqrqoujcjL1V0PLAw/A2ncsAOOvxooG7iu8EThPWin+8Tb+As/d47dM5B4cgGNk0M25rwhuK6bHHH5LjYIUm9zNODTPCuTZZKr8D8e3EsmkKowceSTK955eubyQ6yPYiv5B/0vZ5j9tKZgIcFHzAfUaq//jUveioV86ZjdJmemBtQFsPAmTVK0odLg0iluJ3JrfDAC96g2BcRNzJq5n3X91gyN6Kbfv9mqfdYpsWluI/oMkUNnodif0oWrsr2UNwa3IftvQHNYtbcti1bpEskz6OvySUS++Gtx123ybzEIcwWZQNi9dz/+ldcZ4ofAoZZBucHdudd773F3TcW29xmR4dJqqhQp057FsmY1HG5APBRG4b5khHrOUnTfmajEoqD2rUwqF3L5cRMqNvhzd3cGY7PJYWmHIgzWZ/YUpeHc/Xv6iCxa6f17TjsntQhcN+zcdwilLE73pZHe65+s8UzypzlaoX/9sNBGyUZdQtPovLoSOmxPDb5XR9OWEMCpIwD+TdD4zqOtMFtmHSSxyYHxHdlnycjddzmhKSavXPazfkcoB3IQO5GHsusiKOUu05dZZyAQNljjtCsMMKkm7ZGeZKx6Sfui89F9RJVce00qG4Og5FCVYvtADcDeWbEzbIrYZxEaXExiYCHA3JWvioIRMK59WUmX2nUoP/7kxt6Zctm3Ya4XsrfclZf0Ou5ijJEs7h7H+89EXa63U//8fjtJGI4B38o1XABPUPhvCdNtG+UC534DM0bxX1F79b88W/SZKoiVd2dHMseE5cbIp1ayiNI/GcZdK9wB6G38L2Q2fZjmV8YhOz0n2630qLLkF/cuCrKuHjJ3TLKUSokY2/IS/2LPCny5M5Hmkx5j2WUIuVkBR/VaQ7XapTaTR4MIzmWo5PIeyvJWIgtAvAJBvvJG319LV4UyERzlkTf/tpb8P+Wm6fH/xMAAP//YEpfuTkiAgA=\"") + packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/frontend b/frontend index 461f7d1..23ef7e6 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 461f7d18f804b030781b6a7496517ba26f9ff5b2 +Subproject commit 23ef7e602804ccca1243b88ba0d24769af581190 From 7181645825b7eb17be90ffd9de06d3b02f4fdc90 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 30 Aug 2018 16:45:58 -0700 Subject: [PATCH 099/182] Support deleting of lineup channels --- api/lineup_channel.go | 44 ++++++++++++++++++++++++++++---- models/guide_source_programme.go | 9 +++---- models/lineup_channel.go | 9 +++---- utils/main.go | 15 +++++++++++ 4 files changed, 62 insertions(+), 15 deletions(-) diff --git a/api/lineup_channel.go b/api/lineup_channel.go index fc63f0d..9613719 100644 --- a/api/lineup_channel.go +++ b/api/lineup_channel.go @@ -2,11 +2,13 @@ package api import ( "net/http" + "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/commands" "github.com/tellytv/telly/context" "github.com/tellytv/telly/models" + "github.com/tellytv/telly/utils" ) func getLineup(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { @@ -30,10 +32,31 @@ func addLineupChannel(lineup *models.Lineup, cc *context.CContext, c *gin.Contex } func updateLineupChannels(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { - newChannels := make([]models.LineupChannel, 0) + providedChannels := make([]models.LineupChannel, 0) guideSources := make(map[int]*models.GuideSource) - if c.BindJSON(&newChannels) == nil { - for idx, channel := range newChannels { + existingChannelIDs := make([]string, 0) + passedChannelIDs := make([]string, 0) + + for _, channel := range lineup.Channels { + existingChannelIDs = append(existingChannelIDs, strconv.Itoa(channel.ID)) + } + + if c.BindJSON(&providedChannels) == nil { + for _, channel := range providedChannels { + if channel.ID > 0 { + passedChannelIDs = append(passedChannelIDs, strconv.Itoa(channel.ID)) + } + } + + deletedChannelIDs := utils.Difference(existingChannelIDs, passedChannelIDs) + + for idx, channel := range providedChannels { + if channel.ID > 0 { + passedChannelIDs = append(passedChannelIDs, strconv.Itoa(channel.ID)) + } else if utils.Contains(deletedChannelIDs, strconv.Itoa(channel.ID)) { + // Channel is about to be deleted, no reason to upsert it. + continue + } channel.LineupID = lineup.ID channel.GuideChannel = nil channel.HDHR = nil @@ -45,10 +68,21 @@ func updateLineupChannels(lineup *models.Lineup, cc *context.CContext, c *gin.Co } newChannel.Fill(cc.API) guideSources[newChannel.GuideChannel.GuideSource.ID] = newChannel.GuideChannel.GuideSource - newChannels[idx] = *newChannel + providedChannels[idx] = *newChannel + } + + for _, deletedID := range deletedChannelIDs { + if deleteProgrammesErr := cc.API.GuideSourceProgramme.DeleteGuideSourceProgrammesForChannel(deletedID); deleteProgrammesErr != nil { + c.AbortWithError(http.StatusInternalServerError, deleteProgrammesErr) + return + } + if deleteErr := cc.API.LineupChannel.DeleteLineupChannel(deletedID); deleteErr != nil { + c.AbortWithError(http.StatusInternalServerError, deleteErr) + return + } } - lineup.Channels = newChannels + lineup.Channels = providedChannels // Update guide data for every provider with a new channel in the background for _, source := range guideSources { diff --git a/models/guide_source_programme.go b/models/guide_source_programme.go index 53b499c..fb859ef 100644 --- a/models/guide_source_programme.go +++ b/models/guide_source_programme.go @@ -48,7 +48,7 @@ type GuideSourceProgramme struct { // GuideSourceProgrammeAPI contains all methods for the User struct type GuideSourceProgrammeAPI interface { InsertGuideSourceProgramme(guideID int, programme xmltv.Programme, providerData interface{}) (*GuideSourceProgramme, error) - DeleteGuideSourceProgramme(channelID int) (*GuideSourceProgramme, error) + DeleteGuideSourceProgrammesForChannel(channelID string) error UpdateGuideSourceProgramme(programmeID string, providerData interface{}) error GetGuideSourceProgrammeByID(id int) (*GuideSourceProgramme, error) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) @@ -122,10 +122,9 @@ func (db *GuideSourceProgrammeDB) GetGuideSourceProgrammeByID(id int) (*GuideSou } // DeleteGuideSourceProgramme marks a programme with the given ID as deleted. -func (db *GuideSourceProgrammeDB) DeleteGuideSourceProgramme(programmeID int) (*GuideSourceProgramme, error) { - programme := GuideSourceProgramme{} - err := db.SQL.Get(&programme, `DELETE FROM guide_source_programme WHERE id = $1`, programmeID) - return &programme, err +func (db *GuideSourceProgrammeDB) DeleteGuideSourceProgrammesForChannel(channelID string) error { + _, err := db.SQL.Exec(`DELETE FROM guide_source_programme WHERE channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel WHERE id = ?))`, channelID) + return err } // UpdateGuideSourceProgramme updates a programme. diff --git a/models/lineup_channel.go b/models/lineup_channel.go index cd0137c..f36910e 100644 --- a/models/lineup_channel.go +++ b/models/lineup_channel.go @@ -109,7 +109,7 @@ func (l *LineupChannel) HDHomeRunLineupItem() *HDHomeRunLineupItem { type LineupChannelAPI interface { InsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) UpsertLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) - DeleteLineupChannel(channelID int) (*LineupChannel, error) + DeleteLineupChannel(channelID string) error UpdateLineupChannel(channelStruct LineupChannel) (*LineupChannel, error) GetLineupChannelByID(lineupID int, channelNumber string) (*LineupChannel, error) GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) @@ -169,10 +169,9 @@ func (db *LineupChannelDB) GetLineupChannelByID(lineupID int, channelNumber stri } // DeleteLineupChannel marks a channel with the given ID as deleted. -func (db *LineupChannelDB) DeleteLineupChannel(channelID int) (*LineupChannel, error) { - channel := LineupChannel{} - err := db.SQL.Get(&channel, `DELETE FROM lineup_channel WHERE id = $1`, channelID) - return &channel, err +func (db *LineupChannelDB) DeleteLineupChannel(channelID string) error { + _, err := db.SQL.Exec(`DELETE FROM lineup_channel WHERE id = ?`, channelID) + return err } // UpdateLineupChannel updates a channel. diff --git a/utils/main.go b/utils/main.go index 677ceac..b87f8ff 100644 --- a/utils/main.go +++ b/utils/main.go @@ -181,6 +181,21 @@ func GetStringMapKeys(s map[string]struct{}) []string { return keys } +// Difference returns the elements in a that aren't in b +func Difference(a, b []string) []string { + mb := map[string]bool{} + for _, x := range b { + mb[x] = true + } + ab := []string{} + for _, x := range a { + if _, ok := mb[x]; !ok { + ab = append(ab, x) + } + } + return ab +} + // From https://github.com/stoewer/go-strcase // KebabCase converts a string into kebab case. From 20a77c0d357377eb9cd408f376515a26afca0d88 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 14:58:26 -0700 Subject: [PATCH 100/182] Minor updates to improve artwork handling with SD --- Gopkg.lock | 10 +- Gopkg.toml | 2 +- internal/guideproviders/schedules_direct.go | 112 +++++++++++++++++--- 3 files changed, 104 insertions(+), 20 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index c8b89af..8d6394e 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -115,12 +115,12 @@ version = "1.0.0" [[projects]] - digest = "1:58ad79834dc097c36a857a8c325d646af0a8bbd73375a6958a639507c5399a61" + branch = "master" + digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" name = "github.com/koron/go-ssdp" packages = ["."] pruneopts = "UT" - revision = "6d1709049dead37ead37808479f88c9bffa2c4d6" - version = "v0.1" + revision = "4a0ed625a78b6858dc8d3a55fb7728968b712122" [[projects]] digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394" @@ -307,11 +307,11 @@ [[projects]] branch = "master" - digest = "1:9ae6456cbbd0aca86266e34fad46fcdb27ce7492d7668a8c5d84e5ac0da7aa1d" + digest = "1:990b7cb1f771a9f48b2647d207c6f5356c0bb4372fa744648c95b98ca11ed0f4" name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" - revision = "9386c019cdd72747f7056ed549e035e3cd1aa08e" + revision = "ba31b244c694fa4bd6f8f8417c73e823874d2b33" [[projects]] branch = "master" diff --git a/Gopkg.toml b/Gopkg.toml index 841aa1f..4aad7e9 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -47,7 +47,7 @@ [[constraint]] name = "github.com/koron/go-ssdp" - version = "0.1.0" + branch = "master" [[constraint]] name = "github.com/kr/pretty" diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 74155ca..a5f9e0b 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -4,6 +4,7 @@ import ( "encoding/json" "fmt" "reflect" + "sort" "strconv" "strings" "time" @@ -309,23 +310,23 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input for _, program := range moreInfo { extendedProgramInfo[program.ProgramID] = program if program.HasArtwork() { - programsWithArtwork[program.ProgramID] = struct{}{} + for _, programID := range program.ArtworkLookupIDs() { + programsWithArtwork[programID] = struct{}{} + } } } } - allArtwork := make(map[string][]schedulesdirect.ProgramArtwork, 0) + allArtwork := make(map[string][]schedulesdirect.Artwork, 0) // Now that we have the initial program info results, let's get all the artwork. - for _, chunk := range utils.ChunkStringSlice(utils.GetStringMapKeys(programsWithArtwork), 500) { - artworkResp, artworkErr := s.client.GetArtworkForProgramIDs(chunk) - if artworkErr != nil { - return nil, nil, fmt.Errorf("error when getting artwork from schedules direct: %s", artworkErr) - } + artworkResp, artworkErr := s.client.GetArtworkForProgramIDs(utils.GetStringMapKeys(programsWithArtwork)) + if artworkErr != nil { + return nil, nil, fmt.Errorf("error when getting artwork from schedules direct: %s", artworkErr) + } - for _, artworks := range artworkResp { - allArtwork[artworks.ProgramID] = *artworks.Artwork - } + for _, artworks := range artworkResp { + allArtwork[artworks.ProgramID] = *artworks.Artwork } // We finally have all the data, time to convert to the XMLTV format. @@ -335,7 +336,30 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input for _, schedule := range schedules { station := s.stations[schedule.StationID] for _, airing := range schedule.Programs { - programme, programmeErr := s.processProgrammeToXMLTV(airing, extendedProgramInfo[airing.ProgramID], allArtwork[airing.ProgramID[:10]], station) + programInfo := extendedProgramInfo[airing.ProgramID] + artworks := make([]schedulesdirect.Artwork, 0) + for _, lookupKey := range programInfo.ArtworkLookupIDs() { + if hasArtwork, ok := allArtwork[lookupKey]; ok { + artworks = append(artworks, hasArtwork...) + } + } + + sort.Slice(artworks, func(i, j int) bool { + tier := func(a schedulesdirect.Artwork) int { + return int(parseArtworkTierToOrder(a.Tier)) + } + category := func(a schedulesdirect.Artwork) int { + return int(parseArtworkCategoryToOrder(a.Category)) + } + a := tier(artworks[i]) + b := tier(artworks[i]) + if a == b { + return category(artworks[i]) < category(artworks[j]) + } + return a < b + }) + + programme, programmeErr := s.processProgrammeToXMLTV(airing, extendedProgramInfo[airing.ProgramID], artworks, station) if programmeErr != nil { return nil, nil, fmt.Errorf("error while processing schedules direct result to xmltv format: %s", programmeErr) } @@ -554,11 +578,11 @@ func getXMLTVNumber(mdata []map[string]schedulesdirect.Metadata, multipartInfo * type sdProgrammeData struct { Airing schedulesdirect.Program ProgramInfo schedulesdirect.ProgramInfo - AllArtwork []schedulesdirect.ProgramArtwork + AllArtwork []schedulesdirect.Artwork Station sdStationContainer } -func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program, programInfo schedulesdirect.ProgramInfo, allArtwork []schedulesdirect.ProgramArtwork, station sdStationContainer) (*ProgrammeContainer, error) { +func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program, programInfo schedulesdirect.ProgramInfo, allArtwork []schedulesdirect.Artwork, station sdStationContainer) (*ProgrammeContainer, error) { stationID := fmt.Sprintf("I%s.%s.schedulesdirect.org", station.ChannelMap.Channel, station.Station.StationID) endTime := airing.AirDateTime.Add(time.Duration(airing.Duration) * time.Second) length := xmltv.Length{Units: "seconds", Value: strconv.Itoa(airing.Duration)} @@ -652,7 +676,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program } } - entityTypeCat := programInfo.EntityType + entityTypeCat := string(programInfo.EntityType) if programInfo.EntityType == "episode" { entityTypeCat = "series" @@ -832,3 +856,63 @@ func getDaysBetweenTimes(start, end time.Time) []string { } return dates } + +type artworkTierOrder int + +const ( + EpisodeTier artworkTierOrder = 1 + SeasonTier artworkTierOrder = 2 + SeriesTier artworkTierOrder = 3 + + DontCareTier artworkTierOrder = 10 +) + +func parseArtworkTierToOrder(tier schedulesdirect.ArtworkTier) artworkTierOrder { + switch tier { + case schedulesdirect.EpisodeTier: + return EpisodeTier + case schedulesdirect.SeasonTier: + return SeasonTier + case schedulesdirect.SeriesTier: + return SeriesTier + default: + return DontCareTier + } + + return DontCareTier +} + +type artworkCategoryOrder int + +const ( + BannerL1 artworkCategoryOrder = 1 + BannerL1T artworkCategoryOrder = 2 + Banner artworkCategoryOrder = 3 + BannerL2 artworkCategoryOrder = 4 + BannerL3 artworkCategoryOrder = 5 + BannerLO artworkCategoryOrder = 6 + BannerLOT artworkCategoryOrder = 7 + + DontCareCategory artworkCategoryOrder = 10 +) + +func parseArtworkCategoryToOrder(Category schedulesdirect.ArtworkCategory) artworkCategoryOrder { + switch Category { + case schedulesdirect.BannerL1: + return BannerL1 + case schedulesdirect.BannerL1T: + return BannerL1T + case schedulesdirect.Banner: + return Banner + case schedulesdirect.BannerL2: + return BannerL2 + case schedulesdirect.BannerL3: + return BannerL3 + case schedulesdirect.BannerLO: + return BannerLO + case schedulesdirect.BannerLOT: + return BannerLOT + } + + return DontCareCategory +} From 83c8c241040b206905af736fafafbad0ba6c2d41 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 14:58:47 -0700 Subject: [PATCH 101/182] Ensure default values are set on lineup --- models/lineup.go | 24 ++++++++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/models/lineup.go b/models/lineup.go index ce3ed02..6d4fb83 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -141,6 +141,30 @@ SELECT // InsertLineup inserts a new Lineup into the database. func (db *LineupDB) InsertLineup(lineupStruct Lineup) (*Lineup, error) { lineup := Lineup{} + if lineupStruct.Manufacturer == "" { + lineupStruct.Manufacturer = "Silicondust" + } + if lineupStruct.ModelName == "" { + lineupStruct.ModelName = "HDHomeRun EXTEND" + } + if lineupStruct.ModelNumber == "" { + lineupStruct.ModelNumber = "HDTC-2US" + } + if lineupStruct.FirmwareName == "" { + lineupStruct.FirmwareName = "hdhomeruntc_atsc" + } + if lineupStruct.FirmwareVersion == "" { + lineupStruct.FirmwareVersion = "20150826" + } + if lineupStruct.DeviceID == "" { + lineupStruct.DeviceID = "12345678" + } + if lineupStruct.DeviceAuth == "" { + lineupStruct.DeviceAuth = "telly" + } + if lineupStruct.DeviceUUID == "" { + lineupStruct.DeviceUUID = "12345678-AE2A-4E54-BBC9-33AF7D5D6A92" + } res, err := db.SQL.NamedExec(` INSERT INTO lineup (name, ssdp, listen_address, discovery_address, port, tuners, manufacturer, model_name, model_number, firmware_name, firmware_version, device_id, device_auth, device_uuid) VALUES (:name, :ssdp, :listen_address, :discovery_address, :port, :tuners, :manufacturer, :model_name, :model_number, :firmware_name, :firmware_version, :device_id, :device_auth, :device_uuid)`, lineupStruct) From 536060a8e7999976d74e02895ec68cab93555240 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 17:42:06 -0700 Subject: [PATCH 102/182] Minor SSDP improvements --- api/tuner.go | 31 +++++++++++++++++++------------ 1 file changed, 19 insertions(+), 12 deletions(-) diff --git a/api/tuner.go b/api/tuner.go index e38f7b6..941bae8 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -16,7 +16,7 @@ import ( upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/gin-gonic/gin" - ssdp "github.com/koron/go-ssdp" + "github.com/koron/go-ssdp" "github.com/spf13/viper" ccontext "github.com/tellytv/telly/context" "github.com/tellytv/telly/metrics" @@ -56,7 +56,7 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { baseAddr := fmt.Sprintf("%s:%d", lineup.ListenAddress, lineup.Port) if lineup.SSDP { - if _, ssdpErr := setupSSDP(baseAddr, lineup.Name, lineup.DeviceUUID); ssdpErr != nil { + if ssdpErr := setupSSDP(baseAddr, lineup.Name, lineup.DeviceUUID, exit); ssdpErr != nil { log.WithError(ssdpErr).Errorln("telly cannot advertise over ssdp") } } @@ -88,34 +88,41 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { } } -func setupSSDP(baseAddress, deviceName, deviceUUID string) (*ssdp.Advertiser, error) { - log.Debugf("Advertising telly as %s (%s)", deviceName, deviceUUID) +func setupSSDP(baseAddress, deviceName, deviceUUID string, exit chan bool) error { + log.Debugf("Advertising telly as %s (%s) on %s", deviceName, deviceUUID, baseAddress) adv, err := ssdp.Advertise( - "upnp:rootdevice", + ssdp.RootDevice, fmt.Sprintf("uuid:%s::upnp:rootdevice", deviceUUID), fmt.Sprintf("http://%s/device.xml", baseAddress), - deviceName, + `telly/2.0 UPnP/1.0`, 1800) if err != nil { - return nil, err + return err } - go func(advertiser *ssdp.Advertiser) { - aliveTick := time.Tick(15 * time.Second) + go func() { + aliveTick := time.Tick(300 * time.Second) + loop: for { select { + case <-exit: + break loop case <-aliveTick: - if err := advertiser.Alive(); err != nil { + log.Debugln("Sending SSDP heartbeat") + if err := adv.Alive(); err != nil { log.WithError(err).Panicln("error when sending ssdp heartbeat") } } } - }(adv) - return adv, nil + adv.Bye() + adv.Close() + }() + + return nil } type dXMLContainer struct { From b988d97bd8d380d844791c0183b8eb7a0833b811 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 17:43:47 -0700 Subject: [PATCH 103/182] Improvements to lineup setup and discovery --- models/lineup.go | 28 +++++++++++++++++++++------- models/types.go | 4 ++-- 2 files changed, 23 insertions(+), 9 deletions(-) diff --git a/models/lineup.go b/models/lineup.go index 6d4fb83..589f7e5 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -1,11 +1,15 @@ package models import ( + "crypto/rand" + "encoding/hex" "fmt" + "strings" "time" upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/jmoiron/sqlx" + "github.com/satori/go.uuid" ) // LineupDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -53,14 +57,20 @@ func (d *DiscoveryData) UPNP() upnp.RootDevice { }, URLBaseStr: d.BaseURL, Device: upnp.Device{ - DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", - FriendlyName: d.FriendlyName, - Manufacturer: d.Manufacturer, + DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", + FriendlyName: d.FriendlyName, + Manufacturer: d.Manufacturer, + ManufacturerURL: upnp.URLField{ + Str: "http://www.silicondust.com/", + }, ModelName: d.ModelName, ModelNumber: d.ModelNumber, ModelDescription: fmt.Sprintf("%s %s", d.ModelNumber, d.ModelName), - SerialNumber: d.DeviceID, - UDN: d.DeviceUUID, + ModelURL: upnp.URLField{ + Str: "http://www.silicondust.com/", + }, + SerialNumber: d.DeviceID, + UDN: fmt.Sprintf("uuid:%s", strings.ToUpper(d.DeviceUUID)), PresentationURL: upnp.URLField{ Str: "/", }, @@ -157,13 +167,17 @@ func (db *LineupDB) InsertLineup(lineupStruct Lineup) (*Lineup, error) { lineupStruct.FirmwareVersion = "20150826" } if lineupStruct.DeviceID == "" { - lineupStruct.DeviceID = "12345678" + bytes := make([]byte, 20) + if _, err := rand.Read(bytes); err != nil { + return &lineup, fmt.Errorf("error when generating random device id: %s", err) + } + lineupStruct.DeviceID = strings.ToUpper(hex.EncodeToString(bytes)[:8]) } if lineupStruct.DeviceAuth == "" { lineupStruct.DeviceAuth = "telly" } if lineupStruct.DeviceUUID == "" { - lineupStruct.DeviceUUID = "12345678-AE2A-4E54-BBC9-33AF7D5D6A92" + lineupStruct.DeviceUUID = uuid.Must(uuid.NewV4()).String() } res, err := db.SQL.NamedExec(` INSERT INTO lineup (name, ssdp, listen_address, discovery_address, port, tuners, manufacturer, model_name, model_number, firmware_name, firmware_version, device_id, device_auth, device_uuid) diff --git a/models/types.go b/models/types.go index 9b96157..9cb21d3 100644 --- a/models/types.go +++ b/models/types.go @@ -10,9 +10,9 @@ import ( type ConvertibleBoolean bool // MarshalJSON returns a 0 or 1 depending on bool state. -func (bit *ConvertibleBoolean) MarshalJSON() ([]byte, error) { +func (bit ConvertibleBoolean) MarshalJSON() ([]byte, error) { var bitSetVar int8 - if *bit { + if bit { bitSetVar = 1 } From 5cb90095e2988f16eb8ef118ef9360a3cb01b138 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 17:44:51 -0700 Subject: [PATCH 104/182] Add go.uuid to Gopkg.lock --- Gopkg.lock | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/Gopkg.lock b/Gopkg.lock index 8d6394e..756a4de 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -254,6 +254,14 @@ revision = "b41be1df696709bb6395fe435af20370037c0b4c" version = "v1.1" +[[projects]] + digest = "1:274f67cb6fed9588ea2521ecdac05a6d62a8c51c074c1fccc6a49a40ba80e925" + name = "github.com/satori/go.uuid" + packages = ["."] + pruneopts = "UT" + revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3" + version = "v1.2.0" + [[projects]] digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc" name = "github.com/sirupsen/logrus" @@ -432,6 +440,7 @@ "github.com/prometheus/client_golang/prometheus", "github.com/prometheus/common/version", "github.com/robfig/cron", + "github.com/satori/go.uuid", "github.com/sirupsen/logrus", "github.com/spf13/pflag", "github.com/spf13/viper", From 3db1ba0c6547758995a70c71f29500ef9999cfc3 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 17:51:12 -0700 Subject: [PATCH 105/182] Update go.uuid version.... sometimes I hate godep --- Gopkg.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index 756a4de..8662a85 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -255,11 +255,11 @@ version = "v1.1" [[projects]] - digest = "1:274f67cb6fed9588ea2521ecdac05a6d62a8c51c074c1fccc6a49a40ba80e925" + digest = "1:ff6b0586c0621a76832cf783eee58cbb9d9795d2ce8acbc199a4131db11c42a9" name = "github.com/satori/go.uuid" packages = ["."] pruneopts = "UT" - revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3" + revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e" version = "v1.2.0" [[projects]] From 156f46493bf5fb44fccd56a2f550eb93f873f587 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 1 Sep 2018 18:03:45 -0700 Subject: [PATCH 106/182] Ensure that friendly name always has HDHomerun in it --- models/lineup.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/models/lineup.go b/models/lineup.go index 589f7e5..e34fe3d 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -58,7 +58,7 @@ func (d *DiscoveryData) UPNP() upnp.RootDevice { URLBaseStr: d.BaseURL, Device: upnp.Device{ DeviceType: "urn:schemas-upnp-org:device:MediaServer:1", - FriendlyName: d.FriendlyName, + FriendlyName: fmt.Sprintf("HDHomerun (%s)", d.FriendlyName), Manufacturer: d.Manufacturer, ManufacturerURL: upnp.URLField{ Str: "http://www.silicondust.com/", From 65afcd99374aba759b38f1ae36d2079d52cf4d2a Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 2 Sep 2018 14:14:57 -0700 Subject: [PATCH 107/182] Initial work to simplify live stream management --- Gopkg.lock | 14 +- Gopkg.toml | 2 +- api/main.go | 5 + api/tuner.go | 189 ++++++--------------------- context/context.go | 14 +- internal/streamsuite/stream.go | 199 +++++++++++++++++++++++++++++ internal/streamsuite/transports.go | 101 +++++++++++++++ main.go | 3 - metrics/metrics.go | 52 ++++++-- migrations/00001_init.sql | 1 + models/lineup.go | 9 +- 11 files changed, 410 insertions(+), 179 deletions(-) create mode 100644 internal/streamsuite/stream.go create mode 100644 internal/streamsuite/transports.go diff --git a/Gopkg.lock b/Gopkg.lock index 8662a85..d424dd4 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -68,6 +68,14 @@ revision = "ee1318b82b25993be2f7161d48315e1f14697528" version = "v1.13.3" +[[projects]] + digest = "1:bbadccf3d3317ea03c0dac0b45b673b4b397c8f91a1d2eff550a3c51c4ad770e" + name = "github.com/gogo/protobuf" + packages = ["proto"] + pruneopts = "UT" + revision = "636bf0302bc95575d69441b25a2603156ffdddf1" + version = "v1.1.1" + [[projects]] digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d" name = "github.com/golang/protobuf" @@ -202,15 +210,15 @@ version = "v2.3.0" [[projects]] - digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" + branch = "master" + digest = "1:1e7e38945e6406ec04688d7f020d04fe8d5ea84ea7e0fe220ef2a24cb30acc34" name = "github.com/prometheus/client_golang" packages = [ "prometheus", "prometheus/promhttp", ] pruneopts = "UT" - revision = "c5b7fccd204277076155f10851dad72b76a49317" - version = "v0.8.0" + revision = "676eaf6b948046fcd9dbbcf5cc9ff5077921aa81" [[projects]] branch = "master" diff --git a/Gopkg.toml b/Gopkg.toml index 4aad7e9..7ab4c76 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -67,7 +67,7 @@ [[constraint]] name = "github.com/prometheus/client_golang" - version = "0.8.0" + branch = "master" [[constraint]] branch = "master" diff --git a/api/main.go b/api/main.go index b6110db..063e011 100644 --- a/api/main.go +++ b/api/main.go @@ -1,6 +1,7 @@ package api import ( + "net/http" "os" "github.com/gin-gonic/gin" @@ -67,6 +68,10 @@ func ServeAPI(cc *context.CContext) { apiGroup.POST("/video_sources", wrapContext(cc, addVideoSource)) apiGroup.GET("/video_sources/tracks", wrapContext(cc, getAllTracks)) + apiGroup.GET("/streams", func(c *gin.Context) { + c.JSON(http.StatusOK, cc.Streams) + }) + log.Infof("telly is live and on the air!") log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) diff --git a/api/tuner.go b/api/tuner.go index 941bae8..fa76f08 100644 --- a/api/tuner.go +++ b/api/tuner.go @@ -1,24 +1,20 @@ package api import ( - "bufio" - "bytes" "context" "database/sql" "encoding/xml" "fmt" - "io" "net/http" - "os/exec" - "regexp" "strings" "time" upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/gin-gonic/gin" "github.com/koron/go-ssdp" - "github.com/spf13/viper" + uuid "github.com/satori/go.uuid" ccontext "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/streamsuite" "github.com/tellytv/telly/metrics" "github.com/tellytv/telly/models" ) @@ -34,9 +30,10 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { hdhrItems := make([]models.HDHomeRunLineupItem, 0) for _, channel := range channels { hdhrItems = append(hdhrItems, *channel.HDHR) + log.Infoln("LABELS", lineup.Name, channel.VideoTrack.VideoSource.Name, channel.VideoTrack.VideoSource.Provider) + metrics.ExposedChannels.WithLabelValues(lineup.Name, channel.VideoTrack.VideoSource.Name, channel.VideoTrack.VideoSource.Provider).Inc() } - metrics.ExposedChannels.WithLabelValues(lineup.Name).Set(float64(len(channels))) discoveryData := lineup.GetDiscoveryData() log.Debugln("creating device xml") @@ -161,88 +158,54 @@ func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { } } -func stream(cc *ccontext.CContext, lineup *models.Lineup) gin.HandlerFunc { - return func(c *gin.Context) { - channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(lineup.ID, c.Param("channelNumber")[1:]) - if channelErr != nil { - if channelErr == sql.ErrNoRows { - c.AbortWithError(http.StatusNotFound, fmt.Errorf("unknown channel number %s", channel.ChannelNumber)) - return - } - c.AbortWithError(http.StatusInternalServerError, channelErr) - return +func NewStreamStatus(cc *ccontext.CContext, lineup *models.Lineup, channelID string) (*streamsuite.Stream, string, error) { + statusUUID := uuid.Must(uuid.NewV4()).String() + ss := &streamsuite.Stream{ + UUID: statusUUID, + } + channel, channelErr := cc.API.LineupChannel.GetLineupChannelByID(lineup.ID, channelID) + if channelErr != nil { + if channelErr == sql.ErrNoRows { + return nil, statusUUID, fmt.Errorf("unknown channel number %s", channelID) } + return nil, statusUUID, channelErr + } - log.Infoln("Serving", channel) + ss.Channel = channel - streamURL, streamURLErr := cc.VideoSourceProviders[channel.VideoTrack.VideoSourceID].StreamURL(channel.VideoTrack.StreamID, "ts") - if streamURLErr != nil { - c.AbortWithError(http.StatusInternalServerError, streamURLErr) - return - } + streamURL, streamURLErr := cc.VideoSourceProviders[channel.VideoTrack.VideoSourceID].StreamURL(channel.VideoTrack.StreamID, "ts") + if streamURLErr != nil { + return nil, statusUUID, streamURLErr + } - if !viper.IsSet("iptv.ffmpeg") { - c.Redirect(http.StatusMovedPermanently, streamURL) - return - } + ss.StreamURL = streamURL - log.Infoln("Transcoding stream with ffmpeg") + if lineup.StreamTransport == "ffmpeg" { + ss.Transport = streamsuite.FFMPEG{} + } else { + ss.Transport = streamsuite.HTTP{} + } - run := exec.Command("ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-bsf:v", "h264_mp4toannexb", "-f", "mpegts", "-tune", "zerolatency", "-progress", "pipe:2", "pipe:1") - ffmpegout, err := run.StdoutPipe() - if err != nil { - log.WithError(err).Errorln("StdoutPipe Error") - return - } + ss.PromLabels = []string{lineup.Name, channel.VideoTrack.VideoSource.Name, channel.VideoTrack.VideoSource.Provider, channel.Title, ss.Transport.Type()} - stderr, stderrErr := run.StderrPipe() - if stderrErr != nil { - log.WithError(stderrErr).Errorln("Error creating ffmpeg stderr pipe") - } + return ss, statusUUID, nil +} - if startErr := run.Start(); startErr != nil { - log.WithError(startErr).Errorln("Error starting ffmpeg") +func stream(cc *ccontext.CContext, lineup *models.Lineup) gin.HandlerFunc { + return func(c *gin.Context) { + stream, streamUUID, streamErr := NewStreamStatus(cc, lineup, c.Param("channelNumber")[1:]) + if streamErr != nil { + log.WithError(streamErr).Errorf("Error when starting streaming") + c.AbortWithError(http.StatusInternalServerError, streamErr) return } - metrics.ActiveStreams.WithLabelValues(lineup.Name).Inc() + cc.Streams[streamUUID] = stream - go func() { - scanner := bufio.NewScanner(stderr) - scanner.Split(split) - buf := make([]byte, 2) - scanner.Buffer(buf, bufio.MaxScanTokenSize) + log.Infof("Serving via %s: %s", stream.Transport.Type(), stream.Channel) - for scanner.Scan() { - line := scanner.Text() - status := processFFMPEGStatus(line) - if status != nil { - fmt.Printf("\rFFMPEG Status: channel number: %d bitrate: %s frames: %s total time: %s speed: %s", channel.ID, status.CurrentBitrate, status.FramesProcessed, status.CurrentTime, status.Speed) - } - } - }() + stream.Start(c) - continueStream := true - - streamVideo := func(w io.Writer) bool { - defer func() { - metrics.ActiveStreams.WithLabelValues(lineup.Name).Dec() - log.Infoln("Stopped streaming", channel.ChannelNumber) - if killErr := run.Process.Kill(); killErr != nil { - log.WithError(killErr).Panicln("error when killing ffmpeg") - } - continueStream = false - return - }() - if _, copyErr := io.Copy(w, ffmpegout); copyErr != nil { - log.WithError(copyErr).Errorln("error when streaming from ffmpeg to http") - continueStream = false - return false - } - return continueStream - } - - c.Stream(streamVideo) } } @@ -285,79 +248,3 @@ func lineupStatus(lineup *models.Lineup) gin.HandlerFunc { c.JSON(http.StatusOK, payload) } } - -func split(data []byte, atEOF bool) (advance int, token []byte, spliterror error) { - if atEOF && len(data) == 0 { - return 0, nil, nil - } - if i := bytes.IndexByte(data, '\n'); i >= 0 { - // We have a full newline-terminated line. - return i + 1, data[0:i], nil - } - if i := bytes.IndexByte(data, '\r'); i >= 0 { - // We have a cr terminated line - return i + 1, data[0:i], nil - } - if atEOF { - return len(data), data, nil - } - - return 0, nil, nil -} - -type ffMPEGStatus struct { - FramesProcessed string - CurrentTime string - CurrentBitrate string - Progress float64 - Speed string -} - -func processFFMPEGStatus(line string) *ffMPEGStatus { - status := new(ffMPEGStatus) - if strings.Contains(line, "frame=") && strings.Contains(line, "time=") && strings.Contains(line, "bitrate=") { - var re = regexp.MustCompile(`=\s+`) - st := re.ReplaceAllString(line, `=`) - - f := strings.Fields(st) - var framesProcessed string - var currentTime string - var currentBitrate string - var currentSpeed string - - for j := 0; j < len(f); j++ { - field := f[j] - fieldSplit := strings.Split(field, "=") - - if len(fieldSplit) > 1 { - fieldname := strings.Split(field, "=")[0] - fieldvalue := strings.Split(field, "=")[1] - - if fieldname == "frame" { - framesProcessed = fieldvalue - } - - if fieldname == "time" { - currentTime = fieldvalue - } - - if fieldname == "bitrate" { - currentBitrate = fieldvalue - } - if fieldname == "speed" { - currentSpeed = fieldvalue - if currentSpeed == "1x" { - currentSpeed = "1.000x" - } - } - } - } - - status.CurrentBitrate = currentBitrate - status.FramesProcessed = framesProcessed - status.CurrentTime = currentTime - status.Speed = currentSpeed - return status - } - return nil -} diff --git a/context/context.go b/context/context.go index a29e800..0f58302 100644 --- a/context/context.go +++ b/context/context.go @@ -11,6 +11,7 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/internal/guideproviders" + "github.com/tellytv/telly/internal/streamsuite" "github.com/tellytv/telly/internal/videoproviders" "github.com/tellytv/telly/models" ) @@ -19,9 +20,10 @@ import ( type CContext struct { API *models.APICollection Ctx ctx.Context + GuideSourceProviders map[int]guideproviders.GuideProvider Log *logrus.Logger + Streams map[string]*streamsuite.Stream Tuners map[int]chan bool - GuideSourceProviders map[int]guideproviders.GuideProvider VideoSourceProviders map[int]videoproviders.VideoProvider RawSQL *sqlx.DB @@ -32,11 +34,12 @@ func (cc *CContext) Copy() *CContext { return &CContext{ API: cc.API, Ctx: cc.Ctx, + GuideSourceProviders: cc.GuideSourceProviders, Log: cc.Log, + RawSQL: cc.RawSQL, + Streams: cc.Streams, Tuners: cc.Tuners, - GuideSourceProviders: cc.GuideSourceProviders, VideoSourceProviders: cc.VideoSourceProviders, - RawSQL: cc.RawSQL, } } @@ -128,11 +131,12 @@ func NewCContext() (*CContext, error) { context := &CContext{ API: api, Ctx: theCtx, + GuideSourceProviders: guideSourceProvidersMap, Log: log, + RawSQL: sql, + Streams: make(map[string]*streamsuite.Stream), Tuners: tuners, - GuideSourceProviders: guideSourceProvidersMap, VideoSourceProviders: videoSourceProvidersMap, - RawSQL: sql, } log.Debugln("Context: Context build complete") diff --git a/internal/streamsuite/stream.go b/internal/streamsuite/stream.go new file mode 100644 index 0000000..8268bff --- /dev/null +++ b/internal/streamsuite/stream.go @@ -0,0 +1,199 @@ +package streamsuite + +import ( + "io" + "net" + "net/http" + "os" + "syscall" + "time" + + "github.com/gin-gonic/gin" + "github.com/prometheus/client_golang/prometheus" + "github.com/sirupsen/logrus" + "github.com/tellytv/telly/metrics" + "github.com/tellytv/telly/models" +) + +var ( + log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } +) + +const ( + BufferSize = 1024 * 8 +) + +type Stream struct { + UUID string + Channel *models.LineupChannel + StreamURL string + + Transport StreamTransport + Paused bool + PausedAt *time.Time + StartTime *time.Time + PromLabels []string + PlayTimer *prometheus.Timer `json:"-"` + PauseTimer *prometheus.Timer `json:"-"` + StopNow chan bool `json:"-"` + LastWroteAt *time.Time +} + +func (s *Stream) Start(c *gin.Context) { + now := time.Now() + s.LastWroteAt = &now + s.StartTime = &now + metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Inc() + + s.PlayTimer = prometheus.NewTimer(prometheus.ObserverFunc(func(v float64) { + metrics.StreamPlayingTime.WithLabelValues(s.PromLabels...).Observe(v) + })) + + s.PauseTimer = prometheus.NewTimer(prometheus.ObserverFunc(func(v float64) { + metrics.StreamPausedTime.WithLabelValues(s.PromLabels...).Observe(v) + })) + + streamData, streamErr := s.Transport.Start(s.StreamURL) + if streamErr != nil { + log.WithError(streamErr).Errorf("Error when starting streaming via %s", s.Transport.Type()) + c.AbortWithError(http.StatusInternalServerError, streamErr) + return + } + + defer func() { + if closeErr := streamData.Close(); closeErr != nil { + log.WithError(closeErr).Errorf("error when closing stream via %s", s.Transport.Type()) + return + } + + if stopErr := s.Transport.Stop(); stopErr != nil { + log.WithError(stopErr).Errorf("error when cleaning up stream via %s", s.Transport.Type()) + return + } + }() + + clientGone := c.Writer.CloseNotify() + + go func() { + for { + // Keep the Prometheus timer updated + if !s.Paused { + s.PlayTimer.ObserveDuration() + } else { + s.PauseTimer.ObserveDuration() + } + + // We wait at least 2 full seconds before declaring that a stream is paused. + if time.Now().Sub(*s.LastWroteAt) > 2*time.Second { + s.Pause() + } + } + }() + + for key, value := range s.Transport.Headers() { + c.Writer.Header()[key] = value + } + + buffer := make([]byte, BufferSize) + + writer := wrappedWriter{c.Writer} + +forLoop: + for { + select { + case <-s.StopNow: + break forLoop + case <-clientGone: + log.Debugln("Stream client is disconnected, returning!") + s.Stop() + break forLoop + default: + n, err := streamData.Read(buffer) + + if n == 0 { + log.Debugln("Read 0 bytes from stream source, returning") + s.Unpause(false) + break forLoop + } + + if err != nil { + log.WithError(err).Errorln("Received error while reading from stream source") + s.Unpause(false) + break forLoop + } + + now := time.Now() + s.LastWroteAt = &now + s.Unpause(true) + + data := buffer[:n] + if _, respWriteErr := writer.Write(data); respWriteErr != nil { + if respWriteErr == io.EOF || respWriteErr == io.ErrUnexpectedEOF || respWriteErr == io.ErrClosedPipe { + log.Infoln("CAUGHT IO ERR") + } + log.WithError(respWriteErr).Errorln("Error while writing to connected stream client") + break forLoop + } + c.Writer.Flush() + } + } + +} + +func (s *Stream) Pause() { + if !s.Paused { + s.Paused = true + now := time.Now() + s.PausedAt = &now + metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Dec() + metrics.PausedStreams.WithLabelValues(s.PromLabels...).Inc() + } +} + +func (s *Stream) Unpause(increaseActiveStreams bool) { + if s.Paused { + s.Paused = false + s.PausedAt = nil + metrics.PausedStreams.WithLabelValues(s.PromLabels...).Dec() + if increaseActiveStreams { + metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Inc() + } + } +} + +func (s *Stream) Stop() { + if s.Paused { + metrics.PausedStreams.WithLabelValues(s.PromLabels...).Dec() + } else { + metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Dec() + } + s.Paused = false + if stopErr := s.Transport.Stop(); stopErr != nil { + log.WithError(stopErr).Errorf("error when cleaning up stream via %s", s.Transport.Type()) + return + } +} + +type wrappedWriter struct { + writer io.Writer +} + +func (w wrappedWriter) Write(p []byte) (int, error) { + n, err := w.writer.Write(p) + if err != nil { + // Filter out broken pipe (user pressed "stop") errors + if nErr, ok := err.(*net.OpError); ok { + if nErr.Err == syscall.EPIPE { + return n, nil + } + } + } + return n, err +} diff --git a/internal/streamsuite/transports.go b/internal/streamsuite/transports.go new file mode 100644 index 0000000..ee319e8 --- /dev/null +++ b/internal/streamsuite/transports.go @@ -0,0 +1,101 @@ +package streamsuite + +import ( + "encoding/json" + "fmt" + "io" + "net/http" + "os/exec" + + "github.com/prometheus/common/version" +) + +type StreamTransport interface { + Type() string + Headers() http.Header + Start(streamURL string) (io.ReadCloser, error) + Stop() error +} + +type FFMPEG struct { + run *exec.Cmd +} + +func (f FFMPEG) MarshalJSON() ([]byte, error) { + return json.Marshal(f.Type()) +} + +func (f FFMPEG) Type() string { + return "FFMPEG" +} + +func (f FFMPEG) Headers() http.Header { + return nil +} + +func (f FFMPEG) Start(streamURL string) (io.ReadCloser, error) { + log.Infoln("Transcoding stream with ffmpeg") + f.run = exec.Command("ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") + streamData, stdErr := f.run.StdoutPipe() + if stdErr != nil { + return nil, stdErr + } + + if startErr := f.run.Start(); startErr != nil { + return nil, startErr + } + + return streamData, nil +} + +func (f FFMPEG) Stop() error { + return f.run.Process.Kill() +} + +type HTTP struct { + req *http.Request + resp *http.Response +} + +func (h HTTP) MarshalJSON() ([]byte, error) { + return json.Marshal(h.Type()) +} + +func (h HTTP) Type() string { + return "HTTP" +} + +func (h HTTP) Headers() http.Header { + if h.resp == nil { + return nil + } + return h.resp.Header +} + +func (h HTTP) Start(streamURL string) (io.ReadCloser, error) { + streamReq, reqErr := http.NewRequest("GET", streamURL, nil) + if reqErr != nil { + return nil, reqErr + } + + streamReq.Header.Set("User-Agent", fmt.Sprintf("telly/%s", version.Version)) + + h.req = streamReq + + resp, respErr := http.DefaultClient.Do(streamReq) + if respErr != nil { + return nil, respErr + } + + h.resp = resp + + if resp.StatusCode > 399 { + return nil, fmt.Errorf("unexpected status code %d", resp.StatusCode) + } + + return resp.Body, nil +} + +func (h HTTP) Stop() error { + return nil +} diff --git a/main.go b/main.go index 5f05c05..ff59a36 100644 --- a/main.go +++ b/main.go @@ -87,9 +87,6 @@ func main() { validateConfig() - viper.Set("discovery.device-friendly-name", fmt.Sprintf("HDHomerun (%s)", viper.GetString("discovery.device-friendly-name"))) - viper.Set("discovery.device-uuid", fmt.Sprintf("%d-AE2A-4E54-BBC9-33AF7D5D6A92", viper.GetInt("discovery.device-id"))) - if log.Level == logrus.DebugLevel { js, jsErr := json.MarshalIndent(viper.AllSettings(), "", " ") if jsErr != nil { diff --git a/metrics/metrics.go b/metrics/metrics.go index 680f320..6f4beb1 100644 --- a/metrics/metrics.go +++ b/metrics/metrics.go @@ -11,31 +11,53 @@ var ( ExposedChannels = prometheus.NewGaugeVec( prometheus.GaugeOpts{ Namespace: "telly", - Subsystem: "tuner", - Name: "channels_total", + Subsystem: "channels", + Name: "total", Help: "Number of exposed channels.", }, - []string{"lineup_name"}, + []string{"lineup_name", "video_source_name", "video_source_provider"}, ) // ActiveStreams tracks the realtime number of active streams. ActiveStreams = prometheus.NewGaugeVec( prometheus.GaugeOpts{ Namespace: "telly", - Subsystem: "tuner", - Name: "active_total", - Help: "Number of active streams. Only activated if ffmpeg is enabled.", + Subsystem: "channels", + Name: "active", + Help: "Number of active streams.", }, - []string{"lineup_name"}, + []string{"lineup_name", "video_source_name", "video_source_provider", "channel_name", "stream_transport"}, ) - // StreamTime reports the total amount of time streamed since startup. - StreamTime = prometheus.NewGaugeVec( + // PausedStreams tracks the realtime number of paused streams. + PausedStreams = prometheus.NewGaugeVec( prometheus.GaugeOpts{ Namespace: "telly", - Subsystem: "tuner", - Name: "stream_time", - Help: "Amount of stream time in seconds.", + Subsystem: "channels", + Name: "paused", + Help: "Number of paused streams.", }, - []string{"lineup_name", "channel_name", "channel_number"}, + []string{"lineup_name", "video_source_name", "video_source_provider", "channel_name", "stream_transport"}, + ) + // StreamPlayingTime reports the total amount of time streamed since startup. + StreamPlayingTime = prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Namespace: "telly", + Subsystem: "channels", + Name: "playing_time", + Help: "Amount of stream playing time in seconds.", + Buckets: prometheus.ExponentialBuckets(0.1, 1.5, 5), + }, + []string{"lineup_name", "video_source_name", "video_source_provider", "channel_name", "stream_transport"}, + ) + // StreamPausedTime reports the total amount of time streamed since startup. + StreamPausedTime = prometheus.NewHistogramVec( + prometheus.HistogramOpts{ + Namespace: "telly", + Subsystem: "channels", + Name: "paused_time", + Help: "Amount of stream paused time in seconds.", + Buckets: prometheus.ExponentialBuckets(0.1, 1.5, 5), + }, + []string{"lineup_name", "video_source_name", "video_source_provider", "channel_name", "stream_transport"}, ) ) @@ -43,5 +65,7 @@ func init() { version.NewCollector("telly") prometheus.MustRegister(ExposedChannels) prometheus.MustRegister(ActiveStreams) - prometheus.MustRegister(StreamTime) + prometheus.MustRegister(PausedStreams) + prometheus.MustRegister(StreamPlayingTime) + prometheus.MustRegister(StreamPausedTime) } diff --git a/migrations/00001_init.sql b/migrations/00001_init.sql index 2ceea9e..c3989f1 100644 --- a/migrations/00001_init.sql +++ b/migrations/00001_init.sql @@ -82,6 +82,7 @@ CREATE TABLE IF NOT EXISTS lineup ( device_id TEXT DEFAULT '12345678', device_auth TEXT DEFAULT 'telly', device_uuid TEXT DEFAULT '12345678-AE2A-4E54-BBC9-33AF7D5D6A92', + stream_transport TEXT DEFAULT 'http', created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); diff --git a/models/lineup.go b/models/lineup.go index e34fe3d..07f8773 100644 --- a/models/lineup.go +++ b/models/lineup.go @@ -95,6 +95,7 @@ type Lineup struct { DeviceID string `db:"device_id"` DeviceAuth string `db:"device_auth"` DeviceUUID string `db:"device_uuid"` + StreamTransport string `db:"stream_transport"` CreatedAt *time.Time `db:"created_at"` Channels []LineupChannel @@ -145,6 +146,7 @@ SELECT L.device_id, L.device_auth, L.device_uuid, + L.stream_transport, L.created_at FROM lineup L` @@ -179,9 +181,12 @@ func (db *LineupDB) InsertLineup(lineupStruct Lineup) (*Lineup, error) { if lineupStruct.DeviceUUID == "" { lineupStruct.DeviceUUID = uuid.Must(uuid.NewV4()).String() } + if lineupStruct.StreamTransport == "" { + lineupStruct.StreamTransport = "http" + } res, err := db.SQL.NamedExec(` - INSERT INTO lineup (name, ssdp, listen_address, discovery_address, port, tuners, manufacturer, model_name, model_number, firmware_name, firmware_version, device_id, device_auth, device_uuid) - VALUES (:name, :ssdp, :listen_address, :discovery_address, :port, :tuners, :manufacturer, :model_name, :model_number, :firmware_name, :firmware_version, :device_id, :device_auth, :device_uuid)`, lineupStruct) + INSERT INTO lineup (name, ssdp, listen_address, discovery_address, port, tuners, manufacturer, model_name, model_number, firmware_name, firmware_version, device_id, device_auth, device_uuid, stream_transport) + VALUES (:name, :ssdp, :listen_address, :discovery_address, :port, :tuners, :manufacturer, :model_name, :model_number, :firmware_name, :firmware_version, :device_id, :device_auth, :device_uuid, :stream_transport)`, lineupStruct) if err != nil { return &lineup, err } From 813a40de464578e0189ccc65b5fc8488605f35fe Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 2 Sep 2018 14:18:22 -0700 Subject: [PATCH 108/182] Move everything to internal --- {api => internal/api}/a_api-packr.go | 0 {api => internal/api}/guide_source.go | 4 ++-- {api => internal/api}/lineup.go | 4 ++-- {api => internal/api}/lineup_channel.go | 8 ++++---- {api => internal/api}/main.go | 2 +- {api => internal/api}/tuner.go | 6 +++--- {api => internal/api}/utils.go | 6 +++--- {api => internal/api}/video_source.go | 4 ++-- {api => internal/api}/xmltv.go | 4 ++-- {commands => internal/commands}/guide_updates.go | 4 ++-- {commands => internal/commands}/video_updates.go | 4 ++-- {context => internal/context}/context.go | 2 +- internal/guideproviders/schedules_direct.go | 2 +- internal/guideproviders/xmltv.go | 2 +- {metrics => internal/metrics}/metrics.go | 0 {models => internal/models}/guide_source.go | 0 {models => internal/models}/guide_source_channel.go | 0 {models => internal/models}/guide_source_programme.go | 0 {models => internal/models}/lineup.go | 0 {models => internal/models}/lineup_channel.go | 0 {models => internal/models}/main.go | 0 {models => internal/models}/types.go | 0 {models => internal/models}/video_source.go | 0 {models => internal/models}/video_source_track.go | 0 internal/streamsuite/stream.go | 4 ++-- {utils => internal/utils}/main.go | 0 internal/videoproviders/m3u.go | 2 +- main.go | 10 +++++----- 28 files changed, 34 insertions(+), 34 deletions(-) rename {api => internal/api}/a_api-packr.go (100%) rename {api => internal/api}/guide_source.go (98%) rename {api => internal/api}/lineup.go (93%) rename {api => internal/api}/lineup_channel.go (94%) rename {api => internal/api}/main.go (98%) rename {api => internal/api}/tuner.go (97%) rename {api => internal/api}/utils.go (95%) rename {api => internal/api}/video_source.go (96%) rename {api => internal/api}/xmltv.go (94%) rename {commands => internal/commands}/guide_updates.go (98%) rename {commands => internal/commands}/video_updates.go (90%) rename {context => internal/context}/context.go (99%) rename {metrics => internal/metrics}/metrics.go (100%) rename {models => internal/models}/guide_source.go (100%) rename {models => internal/models}/guide_source_channel.go (100%) rename {models => internal/models}/guide_source_programme.go (100%) rename {models => internal/models}/lineup.go (100%) rename {models => internal/models}/lineup_channel.go (100%) rename {models => internal/models}/main.go (100%) rename {models => internal/models}/types.go (100%) rename {models => internal/models}/video_source.go (100%) rename {models => internal/models}/video_source_track.go (100%) rename {utils => internal/utils}/main.go (100%) diff --git a/api/a_api-packr.go b/internal/api/a_api-packr.go similarity index 100% rename from api/a_api-packr.go rename to internal/api/a_api-packr.go diff --git a/api/guide_source.go b/internal/api/guide_source.go similarity index 98% rename from api/guide_source.go rename to internal/api/guide_source.go index feec59a..bf8da6b 100644 --- a/api/guide_source.go +++ b/internal/api/guide_source.go @@ -6,9 +6,9 @@ import ( "strconv" "github.com/gin-gonic/gin" - "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/guideproviders" - "github.com/tellytv/telly/models" + "github.com/tellytv/telly/internal/models" ) func addGuide(cc *context.CContext, c *gin.Context) { diff --git a/api/lineup.go b/internal/api/lineup.go similarity index 93% rename from api/lineup.go rename to internal/api/lineup.go index d58b417..bc68742 100644 --- a/api/lineup.go +++ b/internal/api/lineup.go @@ -5,8 +5,8 @@ import ( "strconv" "github.com/gin-gonic/gin" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" + "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/models" ) func addLineup(cc *context.CContext, c *gin.Context) { diff --git a/api/lineup_channel.go b/internal/api/lineup_channel.go similarity index 94% rename from api/lineup_channel.go rename to internal/api/lineup_channel.go index 9613719..450ae38 100644 --- a/api/lineup_channel.go +++ b/internal/api/lineup_channel.go @@ -5,10 +5,10 @@ import ( "strconv" "github.com/gin-gonic/gin" - "github.com/tellytv/telly/commands" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" - "github.com/tellytv/telly/utils" + "github.com/tellytv/telly/internal/commands" + "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/models" + "github.com/tellytv/telly/internal/utils" ) func getLineup(lineup *models.Lineup, cc *context.CContext, c *gin.Context) { diff --git a/api/main.go b/internal/api/main.go similarity index 98% rename from api/main.go rename to internal/api/main.go index 063e011..de1c559 100644 --- a/api/main.go +++ b/internal/api/main.go @@ -8,7 +8,7 @@ import ( "github.com/gobuffalo/packr" "github.com/sirupsen/logrus" "github.com/spf13/viper" - "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/context" ginprometheus "github.com/zsais/go-gin-prometheus" ) diff --git a/api/tuner.go b/internal/api/tuner.go similarity index 97% rename from api/tuner.go rename to internal/api/tuner.go index fa76f08..3a4ee34 100644 --- a/api/tuner.go +++ b/internal/api/tuner.go @@ -13,10 +13,10 @@ import ( "github.com/gin-gonic/gin" "github.com/koron/go-ssdp" uuid "github.com/satori/go.uuid" - ccontext "github.com/tellytv/telly/context" + ccontext "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/metrics" + "github.com/tellytv/telly/internal/models" "github.com/tellytv/telly/internal/streamsuite" - "github.com/tellytv/telly/metrics" - "github.com/tellytv/telly/models" ) // ServeLineup starts up a server dedicated to a single Lineup. diff --git a/api/utils.go b/internal/api/utils.go similarity index 95% rename from api/utils.go rename to internal/api/utils.go index 2d68f25..0dc95f3 100644 --- a/api/utils.go +++ b/internal/api/utils.go @@ -9,9 +9,9 @@ import ( "github.com/gobuffalo/packr" "github.com/sirupsen/logrus" "github.com/spf13/viper" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" - "github.com/tellytv/telly/utils" + "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/models" + "github.com/tellytv/telly/internal/utils" ) func scanM3U(c *gin.Context) { diff --git a/api/video_source.go b/internal/api/video_source.go similarity index 96% rename from api/video_source.go rename to internal/api/video_source.go index 98c4325..4ae3274 100644 --- a/api/video_source.go +++ b/internal/api/video_source.go @@ -4,8 +4,8 @@ import ( "net/http" "github.com/gin-gonic/gin" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" + "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/models" ) func getVideoSources(cc *context.CContext, c *gin.Context) { diff --git a/api/xmltv.go b/internal/api/xmltv.go similarity index 94% rename from api/xmltv.go rename to internal/api/xmltv.go index f725ef7..381303b 100644 --- a/api/xmltv.go +++ b/internal/api/xmltv.go @@ -9,7 +9,7 @@ import ( "time" "github.com/gin-gonic/gin" - "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/internal/xmltv" ) @@ -18,7 +18,7 @@ func xmlTV(cc *context.CContext, c *gin.Context) { epg := &xmltv.TV{ Date: time.Now().Format("2006-01-02"), GeneratorInfoName: "telly", - GeneratorInfoURL: "https://github.com/tellytv/telly", + GeneratorInfoURL: "https://github.com/tellytv/telly/internal", } lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(true) diff --git a/commands/guide_updates.go b/internal/commands/guide_updates.go similarity index 98% rename from commands/guide_updates.go rename to internal/commands/guide_updates.go index 2e9ea77..d4b070d 100644 --- a/commands/guide_updates.go +++ b/internal/commands/guide_updates.go @@ -7,9 +7,9 @@ import ( "strings" "github.com/sirupsen/logrus" - "github.com/tellytv/telly/context" + "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/guideproviders" - "github.com/tellytv/telly/models" + "github.com/tellytv/telly/internal/models" ) var ( diff --git a/commands/video_updates.go b/internal/commands/video_updates.go similarity index 90% rename from commands/video_updates.go rename to internal/commands/video_updates.go index 73fa21e..8a61984 100644 --- a/commands/video_updates.go +++ b/internal/commands/video_updates.go @@ -3,8 +3,8 @@ package commands import ( "fmt" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" + "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/models" ) // FireVideoUpdatesCommand Command to fire one off video source updates diff --git a/context/context.go b/internal/context/context.go similarity index 99% rename from context/context.go rename to internal/context/context.go index 0f58302..ab0db71 100644 --- a/context/context.go +++ b/internal/context/context.go @@ -11,9 +11,9 @@ import ( "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/internal/guideproviders" + "github.com/tellytv/telly/internal/models" "github.com/tellytv/telly/internal/streamsuite" "github.com/tellytv/telly/internal/videoproviders" - "github.com/tellytv/telly/models" ) // CContext is a context struct that gets passed around the application. diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index a5f9e0b..a1130d1 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -10,8 +10,8 @@ import ( "time" "github.com/tellytv/go.schedulesdirect" + "github.com/tellytv/telly/internal/utils" "github.com/tellytv/telly/internal/xmltv" - "github.com/tellytv/telly/utils" ) // SchedulesDirect is a GuideProvider supporting the Schedules Direct JSON service. diff --git a/internal/guideproviders/xmltv.go b/internal/guideproviders/xmltv.go index 34c1ae1..0924014 100644 --- a/internal/guideproviders/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -3,8 +3,8 @@ package guideproviders import ( "fmt" + "github.com/tellytv/telly/internal/utils" "github.com/tellytv/telly/internal/xmltv" - "github.com/tellytv/telly/utils" ) // XMLTV is a GuideProvider supporting XMLTV files. diff --git a/metrics/metrics.go b/internal/metrics/metrics.go similarity index 100% rename from metrics/metrics.go rename to internal/metrics/metrics.go diff --git a/models/guide_source.go b/internal/models/guide_source.go similarity index 100% rename from models/guide_source.go rename to internal/models/guide_source.go diff --git a/models/guide_source_channel.go b/internal/models/guide_source_channel.go similarity index 100% rename from models/guide_source_channel.go rename to internal/models/guide_source_channel.go diff --git a/models/guide_source_programme.go b/internal/models/guide_source_programme.go similarity index 100% rename from models/guide_source_programme.go rename to internal/models/guide_source_programme.go diff --git a/models/lineup.go b/internal/models/lineup.go similarity index 100% rename from models/lineup.go rename to internal/models/lineup.go diff --git a/models/lineup_channel.go b/internal/models/lineup_channel.go similarity index 100% rename from models/lineup_channel.go rename to internal/models/lineup_channel.go diff --git a/models/main.go b/internal/models/main.go similarity index 100% rename from models/main.go rename to internal/models/main.go diff --git a/models/types.go b/internal/models/types.go similarity index 100% rename from models/types.go rename to internal/models/types.go diff --git a/models/video_source.go b/internal/models/video_source.go similarity index 100% rename from models/video_source.go rename to internal/models/video_source.go diff --git a/models/video_source_track.go b/internal/models/video_source_track.go similarity index 100% rename from models/video_source_track.go rename to internal/models/video_source_track.go diff --git a/internal/streamsuite/stream.go b/internal/streamsuite/stream.go index 8268bff..7cf50f6 100644 --- a/internal/streamsuite/stream.go +++ b/internal/streamsuite/stream.go @@ -11,8 +11,8 @@ import ( "github.com/gin-gonic/gin" "github.com/prometheus/client_golang/prometheus" "github.com/sirupsen/logrus" - "github.com/tellytv/telly/metrics" - "github.com/tellytv/telly/models" + "github.com/tellytv/telly/internal/metrics" + "github.com/tellytv/telly/internal/models" ) var ( diff --git a/utils/main.go b/internal/utils/main.go similarity index 100% rename from utils/main.go rename to internal/utils/main.go diff --git a/internal/videoproviders/m3u.go b/internal/videoproviders/m3u.go index 8850e00..a5a691c 100644 --- a/internal/videoproviders/m3u.go +++ b/internal/videoproviders/m3u.go @@ -5,7 +5,7 @@ import ( "strconv" "github.com/tellytv/telly/internal/m3uplus" - "github.com/tellytv/telly/utils" + "github.com/tellytv/telly/internal/utils" ) // M3U is a VideoProvider supporting M3U files. diff --git a/main.go b/main.go index ff59a36..010a269 100644 --- a/main.go +++ b/main.go @@ -12,11 +12,11 @@ import ( "github.com/sirupsen/logrus" flag "github.com/spf13/pflag" "github.com/spf13/viper" - "github.com/tellytv/telly/api" - "github.com/tellytv/telly/commands" - "github.com/tellytv/telly/context" - "github.com/tellytv/telly/models" - "github.com/tellytv/telly/utils" + "github.com/tellytv/telly/internal/api" + "github.com/tellytv/telly/internal/commands" + "github.com/tellytv/telly/internal/context" + "github.com/tellytv/telly/internal/models" + "github.com/tellytv/telly/internal/utils" ) var ( From 7f0a2a0dc9637abdaec45956956b8d168cea6ddb Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Sun, 2 Sep 2018 19:35:30 -0400 Subject: [PATCH 109/182] adding closing match and writing new mapping function based on guide source --- internal/api/guide_source.go | 68 ++++++++++++++++++++++++++++-------- 1 file changed, 54 insertions(+), 14 deletions(-) diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index bf8da6b..3171a83 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -6,6 +6,7 @@ import ( "strconv" "github.com/gin-gonic/gin" + "github.com/schollz/closestmatch" "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/internal/models" @@ -101,7 +102,7 @@ func getAllProgrammes(cc *context.CContext, c *gin.Context) { c.JSON(http.StatusOK, programmes) } -func getLineupCoverage(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func getLineupCoverage(source *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { coverage, coverageErr := provider.LineupCoverage() if coverageErr != nil { c.AbortWithError(http.StatusInternalServerError, coverageErr) @@ -110,7 +111,7 @@ func getLineupCoverage(provider guideproviders.GuideProvider, cc *context.CConte c.JSON(http.StatusOK, coverage) } -func getAvailableLineups(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func getAvailableLineups(source *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { countryCode := c.Query("countryCode") postalCode := c.Query("postalCode") lineups, lineupsErr := provider.AvailableLineups(countryCode, postalCode) @@ -121,9 +122,9 @@ func getAvailableLineups(provider guideproviders.GuideProvider, cc *context.CCon c.JSON(http.StatusOK, lineups) } -func previewLineupChannels(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { - lineupId := c.Param("lineupId") - channels, channelsErr := provider.PreviewLineupChannels(lineupId) +func previewLineupChannels(source *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + lineupID := c.Param("lineupId") + channels, channelsErr := provider.PreviewLineupChannels(lineupID) if channelsErr != nil { c.AbortWithError(http.StatusInternalServerError, channelsErr) return @@ -131,18 +132,18 @@ func previewLineupChannels(provider guideproviders.GuideProvider, cc *context.CC c.JSON(http.StatusOK, channels) } -func subscribeToLineup(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { - lineupId := c.Param("lineupId") - if subscribeErr := provider.SubscribeToLineup(lineupId); subscribeErr != nil { +func subscribeToLineup(source *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + lineupID := c.Param("lineupId") + if subscribeErr := provider.SubscribeToLineup(lineupID); subscribeErr != nil { c.AbortWithError(http.StatusInternalServerError, subscribeErr) return } c.JSON(http.StatusOK, gin.H{"status": "okay"}) } -func unsubscribeFromLineup(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { - lineupId := c.Param("lineupId") - if unsubscribeErr := provider.UnsubscribeFromLineup(lineupId); unsubscribeErr != nil { +func unsubscribeFromLineup(source *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + lineupID := c.Param("lineupId") + if unsubscribeErr := provider.UnsubscribeFromLineup(lineupID); unsubscribeErr != nil { c.AbortWithError(http.StatusInternalServerError, unsubscribeErr) return } @@ -165,7 +166,7 @@ func guideSourceRoute(cc *context.CContext, originalFunc func(*models.GuideSourc }) } -func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideproviders.GuideProvider, *context.CContext, *gin.Context)) gin.HandlerFunc { +func guideSourceLineupRoute(cc *context.CContext, originalFunc func(*models.GuideSource, guideproviders.GuideProvider, *context.CContext, *gin.Context)) gin.HandlerFunc { return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { guideSourceID, guideSourceIDErr := strconv.Atoi(c.Param("guideSourceId")) if guideSourceIDErr != nil { @@ -173,6 +174,12 @@ func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideprovide return } + guideSource, guideSourceErr := cc.API.GuideSource.GetGuideSourceByID(guideSourceID) + if guideSourceErr != nil { + c.AbortWithError(http.StatusInternalServerError, guideSourceErr) + return + } + provider, ok := cc.GuideSourceProviders[guideSourceID] if !ok { c.AbortWithError(http.StatusNotFound, fmt.Errorf("%d is not a valid guide source provider", guideSourceID)) @@ -180,10 +187,43 @@ func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideprovide } if !provider.SupportsLineups() { - c.AbortWithError(http.StatusBadRequest, fmt.Errorf("Provider %s does not support lineups", guideSourceID)) + c.AbortWithError(http.StatusBadRequest, fmt.Errorf("Provider %d does not support lineups", guideSourceID)) return } - originalFunc(provider, cc, c) + originalFunc(guideSource, provider, cc, c) }) } + +func match(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { + inputChannelName := c.Query("channelName") // this is a string, ensure it's not empty + + if inputChannelName != "" { + c.JSON(http.StatusOK, gin.H{"status": "empty input"}) + } + channels := make([]string, len(guideSource.Channels)) + channelMap := make(map[string]models.GuideSourceChannel) + + for _, channel := range guideSource.Channels { + name := channel.XMLTV.DisplayNames[0].Value + channels = append(channels, name) + channelMap[name] = channel + } + + bagSizes := []int{3} + + // Create a closestmatch object + cm := closestmatch.New(channels, bagSizes) + + results := cm.ClosestN(inputChannelName, 3) + + var filteredChannels []models.GuideSourceChannel + + for _, result := range results { + filteredChannels = append(filteredChannels, channelMap[result]) + } + + // get matching channels back and form into json for response + + c.JSON(http.StatusOK, filteredChannels) +} From c14722bb4fb00c9dbbdaac7ec4e1ab5dce27be6e Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Sun, 2 Sep 2018 19:35:54 -0400 Subject: [PATCH 110/182] adding new route for the match call --- internal/api/main.go | 1 + 1 file changed, 1 insertion(+) diff --git a/internal/api/main.go b/internal/api/main.go index de1c559..1145dba 100644 --- a/internal/api/main.go +++ b/internal/api/main.go @@ -59,6 +59,7 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/guide_sources/programmes", wrapContext(cc, getAllProgrammes)) apiGroup.GET("/guide_source/:guideSourceId/coverage", guideSourceLineupRoute(cc, getLineupCoverage)) + apiGroup.GET("/guide_source/:guideSourceId/match", guideSourceLineupRoute(cc, match)) apiGroup.GET("/guide_source/:guideSourceId/lineups", guideSourceLineupRoute(cc, getAvailableLineups)) apiGroup.PUT("/guide_source/:guideSourceId/lineups/:lineupId", guideSourceLineupRoute(cc, subscribeToLineup)) apiGroup.DELETE("/guide_source/:guideSourceId/lineups/:lineupId", guideSourceLineupRoute(cc, unsubscribeFromLineup)) From 9b56bba041a74b71a56a545049d50a715c95ee83 Mon Sep 17 00:00:00 2001 From: Mahdi Yusuf Date: Sun, 2 Sep 2018 19:36:04 -0400 Subject: [PATCH 111/182] adding comment for new stream status --- internal/api/tuner.go | 1 + 1 file changed, 1 insertion(+) diff --git a/internal/api/tuner.go b/internal/api/tuner.go index 3a4ee34..6a7707d 100644 --- a/internal/api/tuner.go +++ b/internal/api/tuner.go @@ -158,6 +158,7 @@ func serveHDHRLineup(hdhrItems []models.HDHomeRunLineupItem) gin.HandlerFunc { } } +// NewStreamStatus creates a new stream status func NewStreamStatus(cc *ccontext.CContext, lineup *models.Lineup, channelID string) (*streamsuite.Stream, string, error) { statusUUID := uuid.Must(uuid.NewV4()).String() ss := &streamsuite.Stream{ From da199fd1d6dac2bf9df5ae724e65bd4eeb157667 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 2 Sep 2018 16:44:36 -0700 Subject: [PATCH 112/182] Fix adding a lineup so that it also creates channels in the DB for the new lineup --- internal/api/guide_source.go | 57 +++++++++++++++++---- internal/api/main.go | 2 +- internal/api/tuner.go | 1 - internal/guideproviders/main.go | 2 +- internal/guideproviders/schedules_direct.go | 10 ++-- internal/guideproviders/xmltv.go | 4 +- 6 files changed, 57 insertions(+), 19 deletions(-) diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index bf8da6b..c0d3737 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -101,7 +101,7 @@ func getAllProgrammes(cc *context.CContext, c *gin.Context) { c.JSON(http.StatusOK, programmes) } -func getLineupCoverage(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func getLineupCoverage(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { coverage, coverageErr := provider.LineupCoverage() if coverageErr != nil { c.AbortWithError(http.StatusInternalServerError, coverageErr) @@ -110,7 +110,7 @@ func getLineupCoverage(provider guideproviders.GuideProvider, cc *context.CConte c.JSON(http.StatusOK, coverage) } -func getAvailableLineups(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func getAvailableLineups(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { countryCode := c.Query("countryCode") postalCode := c.Query("postalCode") lineups, lineupsErr := provider.AvailableLineups(countryCode, postalCode) @@ -121,7 +121,7 @@ func getAvailableLineups(provider guideproviders.GuideProvider, cc *context.CCon c.JSON(http.StatusOK, lineups) } -func previewLineupChannels(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func previewLineupChannels(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { lineupId := c.Param("lineupId") channels, channelsErr := provider.PreviewLineupChannels(lineupId) if channelsErr != nil { @@ -131,21 +131,54 @@ func previewLineupChannels(provider guideproviders.GuideProvider, cc *context.CC c.JSON(http.StatusOK, channels) } -func subscribeToLineup(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func subscribeToLineup(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { lineupId := c.Param("lineupId") - if subscribeErr := provider.SubscribeToLineup(lineupId); subscribeErr != nil { + newLineup, subscribeErr := provider.SubscribeToLineup(lineupId) + if subscribeErr != nil { c.AbortWithError(http.StatusInternalServerError, subscribeErr) return } - c.JSON(http.StatusOK, gin.H{"status": "okay"}) + + lineupMetadata, reloadErr := provider.Refresh(nil) + if reloadErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while initializing guide data provider: %s", reloadErr)) + return + } + + if updateErr := cc.API.GuideSource.UpdateGuideSource(guideSource.ID, lineupMetadata); updateErr != nil { + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while updating guide source with provider state: %s", updateErr)) + return + } + + channels, channelsErr := provider.Channels() + if channelsErr != nil { + log.WithError(channelsErr).Errorln("unable to get channels from provider") + c.AbortWithError(http.StatusBadRequest, channelsErr) + return + } + + for _, channel := range channels { + // Only add new channels, not existing ones. + if channel.Lineup == lineupId { + _, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(guideSource.ID, channel, nil) + if newChannelErr != nil { + log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) + c.AbortWithError(http.StatusInternalServerError, newChannelErr) + return + } + } + } + + c.JSON(http.StatusOK, newLineup) } -func unsubscribeFromLineup(provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { +func unsubscribeFromLineup(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { lineupId := c.Param("lineupId") if unsubscribeErr := provider.UnsubscribeFromLineup(lineupId); unsubscribeErr != nil { c.AbortWithError(http.StatusInternalServerError, unsubscribeErr) return } + // FIXME: Remove channels from database that were in removed lineup(s). c.JSON(http.StatusOK, gin.H{"status": "okay"}) } @@ -165,7 +198,7 @@ func guideSourceRoute(cc *context.CContext, originalFunc func(*models.GuideSourc }) } -func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideproviders.GuideProvider, *context.CContext, *gin.Context)) gin.HandlerFunc { +func guideSourceLineupRoute(cc *context.CContext, originalFunc func(*models.GuideSource, guideproviders.GuideProvider, *context.CContext, *gin.Context)) gin.HandlerFunc { return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { guideSourceID, guideSourceIDErr := strconv.Atoi(c.Param("guideSourceId")) if guideSourceIDErr != nil { @@ -173,6 +206,12 @@ func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideprovide return } + guideSource, guideSourceErr := cc.API.GuideSource.GetGuideSourceByID(guideSourceID) + if guideSourceErr != nil { + c.AbortWithError(http.StatusInternalServerError, guideSourceErr) + return + } + provider, ok := cc.GuideSourceProviders[guideSourceID] if !ok { c.AbortWithError(http.StatusNotFound, fmt.Errorf("%d is not a valid guide source provider", guideSourceID)) @@ -184,6 +223,6 @@ func guideSourceLineupRoute(cc *context.CContext, originalFunc func(guideprovide return } - originalFunc(provider, cc, c) + originalFunc(guideSource, provider, cc, c) }) } diff --git a/internal/api/main.go b/internal/api/main.go index de1c559..1247063 100644 --- a/internal/api/main.go +++ b/internal/api/main.go @@ -35,7 +35,7 @@ func ServeAPI(cc *context.CContext) { router := newGin() - box := packr.NewBox("../frontend/dist/telly-fe") + box := packr.NewBox("../../frontend/dist/telly-fe") router.Use(ServeBox("/", box)) diff --git a/internal/api/tuner.go b/internal/api/tuner.go index 3a4ee34..1684cb4 100644 --- a/internal/api/tuner.go +++ b/internal/api/tuner.go @@ -30,7 +30,6 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { hdhrItems := make([]models.HDHomeRunLineupItem, 0) for _, channel := range channels { hdhrItems = append(hdhrItems, *channel.HDHR) - log.Infoln("LABELS", lineup.Name, channel.VideoTrack.VideoSource.Name, channel.VideoTrack.VideoSource.Provider) metrics.ExposedChannels.WithLabelValues(lineup.Name, channel.VideoTrack.VideoSource.Name, channel.VideoTrack.VideoSource.Provider).Inc() } diff --git a/internal/guideproviders/main.go b/internal/guideproviders/main.go index c064256..9054c1d 100644 --- a/internal/guideproviders/main.go +++ b/internal/guideproviders/main.go @@ -130,6 +130,6 @@ type GuideProvider interface { LineupCoverage() ([]CoverageArea, error) AvailableLineups(countryCode, postalCode string) ([]AvailableLineup, error) PreviewLineupChannels(lineupID string) ([]Channel, error) - SubscribeToLineup(providerID string) error + SubscribeToLineup(lineupID string) (interface{}, error) UnsubscribeFromLineup(providerID string) error } diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index a1130d1..3bf9600 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -134,21 +134,21 @@ func (s *SchedulesDirect) PreviewLineupChannels(lineupID string) ([]Channel, err } // SubscribeToLineup will subscribe the user to a lineup. -func (s *SchedulesDirect) SubscribeToLineup(lineupID string) error { +func (s *SchedulesDirect) SubscribeToLineup(lineupID string) (interface{}, error) { if s.client == nil { sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) if sdClientErr != nil { - return fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) + return nil, fmt.Errorf("error setting up schedules direct client: %s", sdClientErr) } s.client = sdClient } - _, addLineupErr := s.client.AddLineup(lineupID) + newLineup, addLineupErr := s.client.AddLineup(lineupID) if addLineupErr != nil { - return fmt.Errorf("error while subscribing to lineup from provider %s: %s", s.Name(), addLineupErr) + return nil, fmt.Errorf("error while subscribing to lineup from provider %s: %s", s.Name(), addLineupErr) } - return nil + return newLineup, nil } // UnsubscribeFromLineup will remove a lineup from the provider account. diff --git a/internal/guideproviders/xmltv.go b/internal/guideproviders/xmltv.go index 0924014..340baf8 100644 --- a/internal/guideproviders/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -51,8 +51,8 @@ func (x *XMLTV) PreviewLineupChannels(lineupID string) ([]Channel, error) { } // SubscribeToLineup will subscribe the user to a lineup. -func (x *XMLTV) SubscribeToLineup(providerID string) error { - return nil +func (x *XMLTV) SubscribeToLineup(lineupID string) (interface{}, error) { + return nil, nil } // UnsubscribeFromLineup will remove a lineup from the provider account. From ffb89e324df763ca1dfdb422ee6fac48a8df1674 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sun, 2 Sep 2018 18:41:11 -0700 Subject: [PATCH 113/182] Update frontend --- frontend | 2 +- internal/api/a_api-packr.go | 18 +++++++++--------- 2 files changed, 10 insertions(+), 10 deletions(-) diff --git a/frontend b/frontend index 23ef7e6..221b5b3 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 23ef7e602804ccca1243b88ba0d24769af581190 +Subproject commit 221b5b3a4fd869b3e14242d0d5f9ed584aa8dc84 diff --git a/internal/api/a_api-packr.go b/internal/api/a_api-packr.go index 97ea389..2144741 100644 --- a/internal/api/a_api-packr.go +++ b/internal/api/a_api-packr.go @@ -7,13 +7,13 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "favicon.ico", "\"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\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "main.js", "\"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\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "polyfills.js", "\"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\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../frontend/dist/telly-fe", "styles.css", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") } From e4f9f8c12bae1263ecd50c42592aa7f7d17c01dd Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 17:19:09 -0700 Subject: [PATCH 114/182] Update circleci config --- .circleci/config.yml | 12 ++++++------ .gometalinter.json | 34 ++++++++++++++++++++++++++++++++++ 2 files changed, 40 insertions(+), 6 deletions(-) create mode 100644 .gometalinter.json diff --git a/.circleci/config.yml b/.circleci/config.yml index 5cfef77..b41ea7c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -2,14 +2,14 @@ version: 2 jobs: build: docker: - - image: circleci/golang:1.8 + - image: circleci/golang:1 working_directory: /go/src/github.com/tellytv/telly steps: - checkout - - - run: go get -v -t -d ./... + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: go get -u github.com/alecthomas/gometalinter + - run: gometalinter --install + - run: dep ensure -vendor-only - run: go test -v ./... - - run: GOOS=linux GOARCH=amd64 go build -o telly_linux_amd64 - - run: GOOS=darwin GOARCH=amd64 go build -o telly_darwin_amd64 - - run: GOOS=windows GOARCH=amd64 go build -o telly_windows_amd64.exe + - run: gometalinter --config=.gometalinter.json ./... diff --git a/.gometalinter.json b/.gometalinter.json new file mode 100644 index 0000000..8addeeb --- /dev/null +++ b/.gometalinter.json @@ -0,0 +1,34 @@ +{ + "Enable": [ + "deadcode", + "errcheck", + "gochecknoinits", + "goconst", + "gofmt", + "goimports", + "golint", + "gosec", + "gotype", + "gotypex", + "ineffassign", + "interfacer", + "megacheck", + "misspell", + "nakedret", + "safesql", + "structcheck", + "test", + "testify", + "unconvert", + "unparam", + "varcheck", + "vet", + "vetshadow" + ], + "Deadline": "5m", + "Sort": [ + "path", + "linter" + ], + "Vendor": true +} From 487cda18d71eadf31599925387d33476935d9433 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 17:49:23 -0700 Subject: [PATCH 115/182] Move from Goose to sql-migrate so we can use built in migrations via packr --- Gopkg.lock | 83 +++++++++++-------- Gopkg.toml | 24 ++++-- internal/context/a_context-packr.go | 12 +++ internal/context/context.go | 28 ++----- ...01_init.sql => 20180905174455-initial.sql} | 7 +- migrations/dbconfig.yml | 11 +++ 6 files changed, 101 insertions(+), 64 deletions(-) create mode 100644 internal/context/a_context-packr.go rename migrations/{00001_init.sql => 20180905174455-initial.sql} (95%) create mode 100644 migrations/dbconfig.yml diff --git a/Gopkg.lock b/Gopkg.lock index d424dd4..4066a1b 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -61,20 +61,12 @@ version = "v1.3.0" [[projects]] - digest = "1:b793158861dda5660883cc91ed3ba69b9b4e3bccff97feb08c34a2fc11b93228" + digest = "1:f45caa3c5c4541c3a73b9fa2b38db97fcbda57618eaaaf45dd5c728362ad8f09" name = "github.com/gobuffalo/packr" packages = ["."] pruneopts = "UT" - revision = "ee1318b82b25993be2f7161d48315e1f14697528" - version = "v1.13.3" - -[[projects]] - digest = "1:bbadccf3d3317ea03c0dac0b45b673b4b397c8f91a1d2eff550a3c51c4ad770e" - name = "github.com/gogo/protobuf" - packages = ["proto"] - pruneopts = "UT" - revision = "636bf0302bc95575d69441b25a2603156ffdddf1" - version = "v1.1.1" + revision = "6c8156ee36301dd007342e79d81c99e7a7834337" + version = "v1.13.5" [[projects]] digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d" @@ -123,12 +115,12 @@ version = "1.0.0" [[projects]] - branch = "master" - digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" + digest = "1:58ad79834dc097c36a857a8c325d646af0a8bbd73375a6958a639507c5399a61" name = "github.com/koron/go-ssdp" packages = ["."] pruneopts = "UT" - revision = "4a0ed625a78b6858dc8d3a55fb7728968b712122" + revision = "6d1709049dead37ead37808479f88c9bffa2c4d6" + version = "v0.1" [[projects]] digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394" @@ -202,23 +194,15 @@ version = "v0.8.0" [[projects]] - digest = "1:65c6401efaeb147041aed03d5b18862ce666a54e4ce754ea6ddbfa5ddaa24b07" - name = "github.com/pressly/goose" - packages = ["."] - pruneopts = "UT" - revision = "95600eb369b1f657efd54a401ab85d0647a1db80" - version = "v2.3.0" - -[[projects]] - branch = "master" - digest = "1:1e7e38945e6406ec04688d7f020d04fe8d5ea84ea7e0fe220ef2a24cb30acc34" + digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" name = "github.com/prometheus/client_golang" packages = [ "prometheus", "prometheus/promhttp", ] pruneopts = "UT" - revision = "676eaf6b948046fcd9dbbcf5cc9ff5077921aa81" + revision = "c5b7fccd204277076155f10851dad72b76a49317" + version = "v0.8.0" [[projects]] branch = "master" @@ -263,13 +247,32 @@ version = "v1.1" [[projects]] - digest = "1:ff6b0586c0621a76832cf783eee58cbb9d9795d2ce8acbc199a4131db11c42a9" + branch = "master" + digest = "1:cd638908d04442c8b6afd5d0221c21556e76c5e7130448ca97d249b47d66dd41" + name = "github.com/rubenv/sql-migrate" + packages = [ + ".", + "sqlparse", + ] + pruneopts = "UT" + revision = "3f452fc0ebebbb784fdab91f7bc79a31dcacab5c" + +[[projects]] + digest = "1:274f67cb6fed9588ea2521ecdac05a6d62a8c51c074c1fccc6a49a40ba80e925" name = "github.com/satori/go.uuid" packages = ["."] pruneopts = "UT" - revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e" + revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3" version = "v1.2.0" +[[projects]] + digest = "1:2b97fd8c3ebafa161b3cf34948a0dd7d1ec27ab3fed686eb3639ead64344e9e6" + name = "github.com/schollz/closestmatch" + packages = ["."] + pruneopts = "UT" + revision = "56fb6b15a5e88fbcbc21b196488e749fc176514c" + version = "v2.1.0" + [[projects]] digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc" name = "github.com/sirupsen/logrus" @@ -323,11 +326,11 @@ [[projects]] branch = "master" - digest = "1:990b7cb1f771a9f48b2647d207c6f5356c0bb4372fa744648c95b98ca11ed0f4" + digest = "1:56994293d84b7c01c28fc1479118038c238742ad24eeff676e11ffc45331e4e2" name = "github.com/tellytv/go.schedulesdirect" packages = ["."] pruneopts = "UT" - revision = "ba31b244c694fa4bd6f8f8417c73e823874d2b33" + revision = "bb2d9eec79e9ab9655574be4faa1e7b952478686" [[projects]] branch = "master" @@ -358,7 +361,7 @@ name = "golang.org/x/crypto" packages = ["ssh/terminal"] pruneopts = "UT" - revision = "614d502a4dac94afa3a6ce146bd1736da82514c6" + revision = "0709b304e793a5edb4a2c0145f281ecdc20838a4" [[projects]] branch = "master" @@ -378,14 +381,14 @@ [[projects]] branch = "master" - digest = "1:0dafafed83f125cdc945a014b2dec15e5b5d8cd2d77a2d1e3763120b08ab381b" + digest = "1:7f4a61b989d94774dc61016b660cf8347f59eb0bed91a10b2f23fc72a38d45d4" name = "golang.org/x/sys" packages = [ "unix", "windows", ] pruneopts = "UT" - revision = "4910a1d54f876d7b22162a85f4d066d3ee649450" + revision = "ebe1bf3edb3325c393447059974de898d5133eb8" [[projects]] digest = "1:4392fcf42d5cf0e3ff78c96b2acf8223d49e4fdc53eb77c99d2f8dfe4680e006" @@ -425,11 +428,20 @@ version = "v8.18.1" [[projects]] - digest = "1:cacb98d52c60c337c2ce95a7af83ba0313a93ce5e73fa9e99a96aff70776b9d3" + digest = "1:fa9a7c0ef59217bd22f32eb7cc027894d73f340a5633258cc079dec025db6a7f" + name = "gopkg.in/gorp.v1" + packages = ["."] + pruneopts = "UT" + revision = "c87af80f3cc5036b55b83d77171e156791085e2e" + version = "v1.7.1" + +[[projects]] + digest = "1:342378ac4dcb378a5448dd723f0784ae519383532f5e70ade24132c4c8693202" name = "gopkg.in/yaml.v2" packages = ["."] pruneopts = "UT" - revision = "a5b47d31c556af34a302ce5d659e6fea44d90de0" + revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183" + version = "v2.2.1" [solve-meta] analyzer-name = "dep" @@ -444,11 +456,12 @@ "github.com/kr/pretty", "github.com/mattn/go-sqlite3", "github.com/mitchellh/mapstructure", - "github.com/pressly/goose", "github.com/prometheus/client_golang/prometheus", "github.com/prometheus/common/version", "github.com/robfig/cron", + "github.com/rubenv/sql-migrate", "github.com/satori/go.uuid", + "github.com/schollz/closestmatch", "github.com/sirupsen/logrus", "github.com/spf13/pflag", "github.com/spf13/viper", diff --git a/Gopkg.toml b/Gopkg.toml index 7ab4c76..fbec1a2 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -39,7 +39,7 @@ [[constraint]] name = "github.com/gobuffalo/packr" - version = "1.13.3" + version = "1.13.5" [[constraint]] branch = "master" @@ -47,7 +47,7 @@ [[constraint]] name = "github.com/koron/go-ssdp" - branch = "master" + version = "0.1.0" [[constraint]] name = "github.com/kr/pretty" @@ -62,16 +62,28 @@ version = "1.0.0" [[constraint]] - name = "github.com/pressly/goose" - version = "2.3.0" + name = "github.com/prometheus/client_golang" + version = "0.8.0" [[constraint]] - name = "github.com/prometheus/client_golang" branch = "master" + name = "github.com/prometheus/common" + +[[constraint]] + name = "github.com/robfig/cron" + version = "1.1.0" [[constraint]] branch = "master" - name = "github.com/prometheus/common" + name = "github.com/rubenv/sql-migrate" + +[[constraint]] + name = "github.com/satori/go.uuid" + version = "1.2.0" + +[[constraint]] + name = "github.com/schollz/closestmatch" + version = "2.1.0" [[constraint]] name = "github.com/sirupsen/logrus" diff --git a/internal/context/a_context-packr.go b/internal/context/a_context-packr.go new file mode 100644 index 0000000..b7417dc --- /dev/null +++ b/internal/context/a_context-packr.go @@ -0,0 +1,12 @@ +// Code generated by github.com/gobuffalo/packr. DO NOT EDIT. + +package context + +import "github.com/gobuffalo/packr" + +// You can use the "packr clean" command to clean up this, +// and any other packr generated files. +func init() { + packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXW2/iOBR+z6/wW0ELVUtvM5qnlJhptDR0g7PqPEWexAVrEzvjCy3/fkVCgh2SLlvtRRoec75z+77jY+OMx+CXnK4EVgREheNMQ+giCJB7P4fAn4FggQB89pdoCTY0JTyWXIuEgIEDAE2B/fMDBL/CEDyF/qMbfgO/wm/AjdDCD6YhfIQBGjkAMJwTywvB59JQCL5LIRrD7244fXDDwe31EATRfL4DaUmEFaELVGApX7lI3wV9x5LEWmRHdeRX2vp+MOC3WCpBcC6tfsu6ihQrEr8I8kMTlmwbJ5oXXCiSxljto/mPcIncxyfgwZkbzRGYRmEIAxQ3Fmf45WQlYiVw8kenHifJYcWiqdlTW6m6pYqDuElnuGR8xbtc1LboDJVgRVZcbNvfSbGKzXb62DyBzJHjADBbhND/GuwoGLQ6HoIQzmAIgym0mR3QdPhXSqw0TcnPcybe8kxtzOFv1xGnWGHT8J/Ovcl2nKwxYyT7+ORX0Q6uxhhXPBxMfTTU32tW/qlxnS6CJQpdP0Bg32asGf2hCYgC/7cIgkFd/KipdThqzXkNsQbcpPDvDnhcCL4SOM+rUe/grzzSe12OtwYWyuTo0DEAhNkKWsbdhJlGz0Xwf1KjYaBfj33/o6rh0a61f0eajDKii+6t8+HFYwom06Jtu18s5tANGsJQGJVSZFQqwmKcpoJIeYjTAM8uJ3fnF+cX55dnpURUJnxDxNZweQ+/E66nwfJ60YwI2WvOMdMvOFFaHDapnW1JM5pwlmqpynw5T0kW2+zYHg/eA89JqBmAzwgGnumm8+99iR48NB1PomUJf6Eif8WCmIls+Dpd85wIzVQSYyUT221DhKScHbtNLi5vLj5NbiuuyYYmxLpOj7i+ur65vftkwrFW6x64Ilm2NbFaG8G7Q49dOHHH1/Dmenx/P/08vrpyZ3fejXfrfp6cGY8KJTCTtdotLpQqSmgiCDZvlhPP8mnn6d175bRDtQ/UebMoqrLul9B+zzfDUxuqJ0n5yqtCGtGqlVG72q+3dbv2/dktJwhvuKDGVjVsR+x+5I3VUGBtuOrroOOuspvsfZJViK4AbSZ6N2uNaTas9RfI46/Mcbxw8bQfETP7lz5DVZZlNlP2GupaLEBFUsenA/rPAAAA//9uhhgAtg0AAA==\"") + packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") +} diff --git a/internal/context/context.go b/internal/context/context.go index ab0db71..21bb49a 100644 --- a/internal/context/context.go +++ b/internal/context/context.go @@ -5,9 +5,10 @@ import ( ctx "context" "os" + "github.com/gobuffalo/packr" "github.com/jmoiron/sqlx" _ "github.com/mattn/go-sqlite3" // the SQLite driver - "github.com/pressly/goose" + "github.com/rubenv/sql-migrate" "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/internal/guideproviders" @@ -57,15 +58,6 @@ func NewCContext() (*CContext, error) { Level: logrus.InfoLevel, } - gooseLog := &logrus.Logger{ - Out: os.Stderr, - Formatter: &logrus.TextFormatter{ - FullTimestamp: true, - }, - Hooks: make(logrus.LevelHooks), - Level: logrus.DebugLevel, - } - sql, dbErr := sqlx.Open("sqlite3", viper.GetString("database.file")) if dbErr != nil { log.WithError(dbErr).Panicln("Unable to open database") @@ -77,19 +69,17 @@ func NewCContext() (*CContext, error) { log.Debugln("Checking migrations status and running any required migrations...") - goose.SetLogger(gooseLog) - - if dialectErr := goose.SetDialect("sqlite3"); dialectErr != nil { - log.WithError(dialectErr).Panicln("error setting migrations dialect") - } + migrate.SetTable("migrations") - if statusErr := goose.Status(sql.DB, "./migrations"); statusErr != nil { - log.WithError(statusErr).Panicln("error getting migrations status") + migrations := &migrate.PackrMigrationSource{ + Box: packr.NewBox("../../migrations"), } - if upErr := goose.Up(sql.DB, "./migrations"); upErr != nil { - log.WithError(upErr).Panicln("error migrating up") + numMigrations, upErr := migrate.Exec(sql.DB, "sqlite3", migrations, migrate.Up) + if upErr != nil { + log.WithError(upErr).Panicln("error migrating database to newer version") } + log.Debugf("successfully applied %d migrations to database", numMigrations) api := models.NewAPICollection(theCtx, sql) diff --git a/migrations/00001_init.sql b/migrations/20180905174455-initial.sql similarity index 95% rename from migrations/00001_init.sql rename to migrations/20180905174455-initial.sql index c3989f1..c1913d2 100644 --- a/migrations/00001_init.sql +++ b/migrations/20180905174455-initial.sql @@ -1,5 +1,5 @@ --- +goose Up --- SQL in this section is executed when the migration is applied. + +-- +migrate Up CREATE TABLE IF NOT EXISTS video_source ( id INTEGER PRIMARY KEY AUTOINCREMENT, @@ -103,8 +103,7 @@ CREATE TABLE IF NOT EXISTS lineup_channel ( ); --- +goose Down --- SQL in this section is executed when the migration is rolled back. +-- +migrate Down DROP TABLE video_source; DROP TABLE video_source_track; diff --git a/migrations/dbconfig.yml b/migrations/dbconfig.yml new file mode 100644 index 0000000..953c99c --- /dev/null +++ b/migrations/dbconfig.yml @@ -0,0 +1,11 @@ +development: + dialect: sqlite3 + datasource: telly.db + dir: migrations + table: migrations + +production: + dialect: sqlite3 + datasource: telly.db + dir: migrations + table: migrations From 34059eb4934f12190cf5635e446284464637fa5e Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 18:27:52 -0700 Subject: [PATCH 116/182] Update CircleCI to build Docker images with promu --- .circleci/config.yml | 103 +++++++++++++++++++++++++++++++++++++++---- Makefile | 36 ++++++++++----- VERSION | 2 +- 3 files changed, 121 insertions(+), 20 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index b41ea7c..964d807 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1,15 +1,102 @@ +--- version: 2 + jobs: + test: + docker: + - image: circleci/golang:1.10 + working_directory: /go/src/github.com/tellytv/telly + + steps: + - checkout + - setup_remote_docker + - run: make promu + - run: make + build: + machine: true + working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly + + steps: + - checkout + - run: make promu + - run: promu crossbuild -v + - persist_to_workspace: + root: . + paths: + - .build + + docker_hub_master: docker: - - image: circleci/golang:1 + - image: circleci/golang:1.10 + working_directory: /go/src/github.com/tellytv/telly + + steps: + - checkout + - setup_remote_docker + - attach_workspace: + at: . + - run: ln -s .build/linux-amd64/telly telly + - run: make docker + - run: docker images + - run: docker login -u $DOCKER_LOGIN -p $DOCKER_PASSWORD + - run: make docker-publish + docker_hub_release_tags: + docker: + - image: circleci/golang:1.10 working_directory: /go/src/github.com/tellytv/telly + steps: - - checkout - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - - run: go get -u github.com/alecthomas/gometalinter - - run: gometalinter --install - - run: dep ensure -vendor-only - - run: go test -v ./... - - run: gometalinter --config=.gometalinter.json ./... + - checkout + - setup_remote_docker + - run: mkdir -v -p ${HOME}/bin + - run: curl -L 'https://github.com/aktau/github-release/releases/download/v0.7.2/linux-amd64-github-release.tar.bz2' | tar xvjf - --strip-components 3 -C ${HOME}/bin + - run: echo 'export PATH=${HOME}/bin:${PATH}' >> ${BASH_ENV} + - attach_workspace: + at: . + - run: make promu + - run: promu crossbuild tarballs + - run: promu checksum .tarballs + - run: promu release .tarballs + - store_artifacts: + path: .tarballs + destination: releases + - run: ln -s .build/linux-amd64/telly telly + - run: make docker DOCKER_IMAGE_TAG=$CIRCLE_TAG + - run: docker login -u $DOCKER_LOGIN -p $DOCKER_PASSWORD + - run: | + if [[ "$CIRCLE_TAG" =~ ^v[0-9]+(\.[0-9]+){2}$ ]]; then + make docker-tag-latest DOCKER_IMAGE_TAG="$CIRCLE_TAG" + + fi + - run: make docker-publish + +workflows: + version: 2 + telly: + jobs: + - test: + filters: + tags: + only: /.*/ + - build: + filters: + tags: + only: /.*/ + - docker_hub_master: + requires: + - test + - build + filters: + branches: + only: master + - docker_hub_release_tags: + requires: + - test + - build + filters: + tags: + only: /^v[0-9]+(\.[0-9]+){2}(-.+|[^-.]*)$/ + branches: + ignore: /.*/ diff --git a/Makefile b/Makefile index db0c78e..27894bd 100644 --- a/Makefile +++ b/Makefile @@ -1,6 +1,10 @@ -GO := GO15VENDOREXPERIMENT=1 go -PROMU := $(GOPATH)/bin/promu -pkgs = $(shell $(GO) list ./... | grep -v /vendor/) +GO ?= go +GOFMT ?= $(GO)fmt +FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH))) +PROMU := $(FIRST_GOPATH)/bin/promu + +GOMETALINTER_BINARY := $(FIRST_GOPATH)/bin/gometalinter +DEP_BINARY := $(FIRST_GOPATH)/bin/dep PREFIX ?= $(shell pwd) BIN_DIR ?= $(shell pwd) @@ -8,23 +12,29 @@ DOCKER_IMAGE_NAME ?= telly DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD)) -all: format build test +all: style dep build test style: @echo ">> checking code style" - @! gofmt -d $(shell find . -path ./vendor -prune -o -name '*.go' -print) | grep '^' + @$(GO) get -u github.com/alecthomas/gometalinter + @$(GOMETALINTER_BINARY) --config=.gometalinter.json --install + @$(GOMETALINTER_BINARY) --config=.gometalinter.json ./... + +dep: $(DEP_BINARY) + @echo ">> installing dependencies" + @$(DEP_BINARY) ensure -vendor-only -v test: @echo ">> running tests" - @$(GO) test -short $(pkgs) + @$(GO) test -short ./... format: @echo ">> formatting code" - @$(GO) fmt $(pkgs) + @$(GOFMT) . vet: @echo ">> vetting code" - @$(GO) vet $(pkgs) + @$(GO) vet ./... build: promu @echo ">> building binaries" @@ -38,14 +48,18 @@ docker: @echo ">> building docker image" @docker build -t "$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . +docker-publish: + @echo ">> publishing docker image" + @docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" + promu: @GOOS=$(shell uname -s | tr A-Z a-z) \ GOARCH=$(subst x86_64,amd64,$(patsubst i%86,386,$(shell uname -m))) \ $(GO) get -u github.com/prometheus/promu -.PHONY: all style format build test vet tarball docker promu +.PHONY: all style dep format build test vet tarball docker docker-publish promu -run: - go run *.go \ No newline at end of file +run: + go run *.go diff --git a/VERSION b/VERSION index a3fdef3..bc80560 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.1.0.2 +1.5.0 From 065b60960fe9eec530c535e184c10697c638fa3d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 18:33:20 -0700 Subject: [PATCH 117/182] Update versions, ensure dep runs --- .circleci/config.yml | 2 ++ Gopkg.lock | 27 ++++++++++++++++++--------- Gopkg.toml | 6 +++--- 3 files changed, 23 insertions(+), 12 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 964d807..d4ddef3 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -20,6 +20,7 @@ jobs: steps: - checkout - run: make promu + - run: make dep - run: promu crossbuild -v - persist_to_workspace: root: . @@ -56,6 +57,7 @@ jobs: - attach_workspace: at: . - run: make promu + - run: make dep - run: promu crossbuild tarballs - run: promu checksum .tarballs - run: promu release .tarballs diff --git a/Gopkg.lock b/Gopkg.lock index 4066a1b..143e87e 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -68,6 +68,14 @@ revision = "6c8156ee36301dd007342e79d81c99e7a7834337" version = "v1.13.5" +[[projects]] + digest = "1:bbadccf3d3317ea03c0dac0b45b673b4b397c8f91a1d2eff550a3c51c4ad770e" + name = "github.com/gogo/protobuf" + packages = ["proto"] + pruneopts = "UT" + revision = "636bf0302bc95575d69441b25a2603156ffdddf1" + version = "v1.1.1" + [[projects]] digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d" name = "github.com/golang/protobuf" @@ -115,12 +123,12 @@ version = "1.0.0" [[projects]] - digest = "1:58ad79834dc097c36a857a8c325d646af0a8bbd73375a6958a639507c5399a61" + branch = "master" + digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" name = "github.com/koron/go-ssdp" packages = ["."] pruneopts = "UT" - revision = "6d1709049dead37ead37808479f88c9bffa2c4d6" - version = "v0.1" + revision = "4a0ed625a78b6858dc8d3a55fb7728968b712122" [[projects]] digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394" @@ -194,15 +202,16 @@ version = "v0.8.0" [[projects]] - digest = "1:d14a5f4bfecf017cb780bdde1b6483e5deb87e12c332544d2c430eda58734bcb" + branch = "master" + digest = "1:85e2aede1e81915ef1d12551ea082ce6aab0e0cfb70f7b29581ef496e1b0ec0d" name = "github.com/prometheus/client_golang" packages = [ "prometheus", + "prometheus/internal", "prometheus/promhttp", ] pruneopts = "UT" - revision = "c5b7fccd204277076155f10851dad72b76a49317" - version = "v0.8.0" + revision = "3525612fea19680dd3d49c768802ec082ca853b2" [[projects]] branch = "master" @@ -258,12 +267,12 @@ revision = "3f452fc0ebebbb784fdab91f7bc79a31dcacab5c" [[projects]] - digest = "1:274f67cb6fed9588ea2521ecdac05a6d62a8c51c074c1fccc6a49a40ba80e925" + branch = "master" + digest = "1:ff6b0586c0621a76832cf783eee58cbb9d9795d2ce8acbc199a4131db11c42a9" name = "github.com/satori/go.uuid" packages = ["."] pruneopts = "UT" - revision = "f58768cc1a7a7e77a3bd49e98cdd21419399b6a3" - version = "v1.2.0" + revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e" [[projects]] digest = "1:2b97fd8c3ebafa161b3cf34948a0dd7d1ec27ab3fed686eb3639ead64344e9e6" diff --git a/Gopkg.toml b/Gopkg.toml index fbec1a2..6167e7c 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -47,7 +47,7 @@ [[constraint]] name = "github.com/koron/go-ssdp" - version = "0.1.0" + branch = "master" [[constraint]] name = "github.com/kr/pretty" @@ -63,7 +63,7 @@ [[constraint]] name = "github.com/prometheus/client_golang" - version = "0.8.0" + branch = "master" [[constraint]] branch = "master" @@ -79,7 +79,7 @@ [[constraint]] name = "github.com/satori/go.uuid" - version = "1.2.0" + branch = "master" [[constraint]] name = "github.com/schollz/closestmatch" From 64a0ea7f070c8a0503124312ff84d3c8c60796b4 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 18:34:22 -0700 Subject: [PATCH 118/182] Install dep --- Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile b/Makefile index 27894bd..0197250 100644 --- a/Makefile +++ b/Makefile @@ -22,6 +22,7 @@ style: dep: $(DEP_BINARY) @echo ">> installing dependencies" + @curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh @$(DEP_BINARY) ensure -vendor-only -v test: From ad98f3662fa4892edcba6d1fb9df84ff6279f2fd Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 18:37:17 -0700 Subject: [PATCH 119/182] Get circleci to install dep --- .circleci/config.yml | 2 ++ Makefile | 1 - 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index d4ddef3..e3e185c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -20,6 +20,7 @@ jobs: steps: - checkout - run: make promu + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: make dep - run: promu crossbuild -v - persist_to_workspace: @@ -57,6 +58,7 @@ jobs: - attach_workspace: at: . - run: make promu + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: make dep - run: promu crossbuild tarballs - run: promu checksum .tarballs diff --git a/Makefile b/Makefile index 0197250..27894bd 100644 --- a/Makefile +++ b/Makefile @@ -22,7 +22,6 @@ style: dep: $(DEP_BINARY) @echo ">> installing dependencies" - @curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh @$(DEP_BINARY) ensure -vendor-only -v test: From af02a0be41bb022fafcfbadcd857f8bb76af7cbd Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:10:28 -0700 Subject: [PATCH 120/182] Gometalinter fixes --- .gometalinter.json | 8 +++ Makefile | 5 +- internal/api/a_api-packr.go | 18 +++--- internal/api/guide_source.go | 36 +++++------ internal/api/lineup_channel.go | 4 +- internal/api/tuner.go | 15 +++-- internal/api/utils.go | 6 +- internal/api/xmltv.go | 2 +- internal/commands/video_updates.go | 6 +- internal/context/a_context-packr.go | 4 +- internal/context/context.go | 2 +- internal/guideproviders/main.go | 8 +-- internal/guideproviders/schedules_direct.go | 66 ++++++++++----------- internal/guideproviders/xmltv.go | 2 +- internal/metrics/metrics.go | 1 + internal/models/guide_source.go | 7 ++- internal/models/guide_source_channel.go | 14 ++++- internal/models/guide_source_programme.go | 28 +++++++-- internal/models/lineup.go | 7 ++- internal/models/lineup_channel.go | 38 ++++++++++-- internal/models/main.go | 6 +- internal/models/video_source.go | 10 +++- internal/models/video_source_track.go | 19 +++++- internal/streamsuite/stream.go | 8 ++- internal/streamsuite/transports.go | 17 +++++- internal/utils/main.go | 35 ++++------- internal/videoproviders/m3u.go | 4 +- internal/videoproviders/main.go | 7 ++- internal/xmltv/xmltv.go | 10 +--- internal/xmltv/xmltv_test.go | 34 +++++------ main.go | 13 ++-- 31 files changed, 271 insertions(+), 169 deletions(-) diff --git a/.gometalinter.json b/.gometalinter.json index 8addeeb..cbc79b6 100644 --- a/.gometalinter.json +++ b/.gometalinter.json @@ -25,7 +25,15 @@ "vet", "vetshadow" ], + "Exclude": [ + "^vendor\/", + ".*-packr.go.*", + ".*squirrel.v1.*", + ".*tableName is unused.*", + "error return value not checked .*c.AbortWithError.*" + ], "Deadline": "5m", + "Skip": ["../vendor"], "Sort": [ "path", "linter" diff --git a/Makefile b/Makefile index 27894bd..b780682 100644 --- a/Makefile +++ b/Makefile @@ -1,9 +1,10 @@ -GO ?= go +# Need CGO_ENABLED=1 for go-sqlite3 +GO ?= CGO_ENABLED=1 go GOFMT ?= $(GO)fmt FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH))) PROMU := $(FIRST_GOPATH)/bin/promu -GOMETALINTER_BINARY := $(FIRST_GOPATH)/bin/gometalinter +GOMETALINTER_BINARY := CGO_ENABLED=1 $(FIRST_GOPATH)/bin/gometalinter DEP_BINARY := $(FIRST_GOPATH)/bin/dep PREFIX ?= $(shell pwd) diff --git a/internal/api/a_api-packr.go b/internal/api/a_api-packr.go index 2144741..b78e6bf 100644 --- a/internal/api/a_api-packr.go +++ b/internal/api/a_api-packr.go @@ -7,13 +7,13 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index 26dd34f..05be4aa 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -133,8 +133,8 @@ func previewLineupChannels(guideSource *models.GuideSource, provider guideprovid } func subscribeToLineup(guideSource *models.GuideSource, provider guideproviders.GuideProvider, cc *context.CContext, c *gin.Context) { - lineupId := c.Param("lineupId") - newLineup, subscribeErr := provider.SubscribeToLineup(lineupId) + lineupID := c.Param("lineupId") + newLineup, subscribeErr := provider.SubscribeToLineup(lineupID) if subscribeErr != nil { c.AbortWithError(http.StatusInternalServerError, subscribeErr) return @@ -160,7 +160,7 @@ func subscribeToLineup(guideSource *models.GuideSource, provider guideproviders. for _, channel := range channels { // Only add new channels, not existing ones. - if channel.Lineup == lineupId { + if channel.Lineup == lineupID { _, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(guideSource.ID, channel, nil) if newChannelErr != nil { log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) @@ -183,21 +183,21 @@ func unsubscribeFromLineup(guideSource *models.GuideSource, provider guideprovid c.JSON(http.StatusOK, gin.H{"status": "okay"}) } -func guideSourceRoute(cc *context.CContext, originalFunc func(*models.GuideSource, *context.CContext, *gin.Context)) gin.HandlerFunc { - return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { - guideSourceID, guideSourceIDErr := strconv.Atoi(c.Param("guideSourceId")) - if guideSourceIDErr != nil { - c.AbortWithError(http.StatusBadRequest, guideSourceIDErr) - return - } - guideSource, guideSourceErr := cc.API.GuideSource.GetGuideSourceByID(guideSourceID) - if guideSourceErr != nil { - c.AbortWithError(http.StatusInternalServerError, guideSourceErr) - return - } - originalFunc(guideSource, cc, c) - }) -} +// func guideSourceRoute(cc *context.CContext, originalFunc func(*models.GuideSource, *context.CContext, *gin.Context)) gin.HandlerFunc { +// return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { +// guideSourceID, guideSourceIDErr := strconv.Atoi(c.Param("guideSourceId")) +// if guideSourceIDErr != nil { +// c.AbortWithError(http.StatusBadRequest, guideSourceIDErr) +// return +// } +// guideSource, guideSourceErr := cc.API.GuideSource.GetGuideSourceByID(guideSourceID) +// if guideSourceErr != nil { +// c.AbortWithError(http.StatusInternalServerError, guideSourceErr) +// return +// } +// originalFunc(guideSource, cc, c) +// }) +// } func guideSourceLineupRoute(cc *context.CContext, originalFunc func(*models.GuideSource, guideproviders.GuideProvider, *context.CContext, *gin.Context)) gin.HandlerFunc { return wrapContext(cc, func(cc *context.CContext, c *gin.Context) { diff --git a/internal/api/lineup_channel.go b/internal/api/lineup_channel.go index 450ae38..27809f1 100644 --- a/internal/api/lineup_channel.go +++ b/internal/api/lineup_channel.go @@ -51,9 +51,7 @@ func updateLineupChannels(lineup *models.Lineup, cc *context.CContext, c *gin.Co deletedChannelIDs := utils.Difference(existingChannelIDs, passedChannelIDs) for idx, channel := range providedChannels { - if channel.ID > 0 { - passedChannelIDs = append(passedChannelIDs, strconv.Itoa(channel.ID)) - } else if utils.Contains(deletedChannelIDs, strconv.Itoa(channel.ID)) { + if utils.Contains(deletedChannelIDs, strconv.Itoa(channel.ID)) { // Channel is about to be deleted, no reason to upsert it. continue } diff --git a/internal/api/tuner.go b/internal/api/tuner.go index 89b20f8..0283909 100644 --- a/internal/api/tuner.go +++ b/internal/api/tuner.go @@ -70,6 +70,7 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { } }() + // nolint for { select { case <-exit: @@ -99,14 +100,14 @@ func setupSSDP(baseAddress, deviceName, deviceUUID string, exit chan bool) error } go func() { - aliveTick := time.Tick(300 * time.Second) + aliveTick := time.NewTicker(300 * time.Second) loop: for { select { case <-exit: break loop - case <-aliveTick: + case <-aliveTick.C: log.Debugln("Sending SSDP heartbeat") if err := adv.Alive(); err != nil { log.WithError(err).Panicln("error when sending ssdp heartbeat") @@ -114,8 +115,12 @@ func setupSSDP(baseAddress, deviceName, deviceUUID string, exit chan bool) error } } - adv.Bye() - adv.Close() + if byeErr := adv.Bye(); byeErr != nil { + log.WithError(byeErr).Panicln("error when sending ssdp bye") + } + if closeErr := adv.Close(); closeErr != nil { + log.WithError(closeErr).Panicln("error when closing ssdp") + } }() return nil @@ -183,7 +188,7 @@ func NewStreamStatus(cc *ccontext.CContext, lineup *models.Lineup, channelID str if lineup.StreamTransport == "ffmpeg" { ss.Transport = streamsuite.FFMPEG{} } else { - ss.Transport = streamsuite.HTTP{} + ss.Transport = &streamsuite.HTTP{} } ss.PromLabels = []string{lineup.Name, channel.VideoTrack.VideoSource.Name, channel.VideoTrack.VideoSource.Provider, channel.Title, ss.Transport.Type()} diff --git a/internal/api/utils.go b/internal/api/utils.go index 0dc95f3..d0f1c2d 100644 --- a/internal/api/utils.go +++ b/internal/api/utils.go @@ -15,7 +15,7 @@ import ( ) func scanM3U(c *gin.Context) { - rawPlaylist, m3uErr := utils.GetM3U(c.Query("m3u_url"), false) + rawPlaylist, m3uErr := utils.GetM3U(c.Query("m3u_url")) if m3uErr != nil { log.WithError(m3uErr).Errorln("unable to get m3u file") c.AbortWithError(http.StatusBadRequest, m3uErr) @@ -26,7 +26,7 @@ func scanM3U(c *gin.Context) { } func scanXMLTV(c *gin.Context) { - epg, epgErr := utils.GetXMLTV(c.Query("epg_url"), false) + epg, epgErr := utils.GetXMLTV(c.Query("epg_url")) if epgErr != nil { c.AbortWithError(http.StatusInternalServerError, epgErr) return @@ -118,7 +118,6 @@ func StartTuner(cc *context.CContext, lineup *models.Lineup) { tunerChan := make(chan bool) cc.Tuners[lineup.ID] = tunerChan go ServeLineup(cc, tunerChan, lineup) - return } // RestartTuner will trigger a restart of the tuner server for the given lineup. @@ -127,5 +126,4 @@ func RestartTuner(cc *context.CContext, lineup *models.Lineup) { tuner <- true } StartTuner(cc, lineup) - return } diff --git a/internal/api/xmltv.go b/internal/api/xmltv.go index 381303b..8a69581 100644 --- a/internal/api/xmltv.go +++ b/internal/api/xmltv.go @@ -48,7 +48,7 @@ func xmlTV(cc *context.CContext, c *gin.Context) { xChannel := guideChannel.XMLTV() - displayNames := []xmltv.CommonElement{xmltv.CommonElement{Value: channel.Title}} + displayNames := []xmltv.CommonElement{{Value: channel.Title}} displayNames = append(displayNames, xChannel.DisplayNames...) epg.Channels = append(epg.Channels, xmltv.Channel{ diff --git a/internal/commands/video_updates.go b/internal/commands/video_updates.go index 8a61984..ec6e6ec 100644 --- a/internal/commands/video_updates.go +++ b/internal/commands/video_updates.go @@ -13,19 +13,19 @@ func FireVideoUpdatesCommand() { if err != nil { panic(fmt.Errorf("couldn't create context: %s", err)) } - if err = fireVideoUpdates(cc); err != nil { + if err = fireVideoUpdates(cc, nil); err != nil { panic(fmt.Errorf("could not complete video updates: %s", err)) } } -func fireVideoUpdates(cc *context.CContext) error { +func fireVideoUpdates(cc *context.CContext, provider *models.VideoSource) error { fmt.Println("VIDEO source update is beginning") return nil } // StartFireVideoUpdates Scheduler triggered function to update video sources func StartFireVideoUpdates(cc *context.CContext, provider *models.VideoSource) { - err := fireVideoUpdates(cc) + err := fireVideoUpdates(cc, provider) if err != nil { panic(fmt.Errorf("could not complete video updates: %s", err.Error())) } diff --git a/internal/context/a_context-packr.go b/internal/context/a_context-packr.go index b7417dc..1ee89ea 100644 --- a/internal/context/a_context-packr.go +++ b/internal/context/a_context-packr.go @@ -7,6 +7,6 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXW2/iOBR+z6/wW0ELVUtvM5qnlJhptDR0g7PqPEWexAVrEzvjCy3/fkVCgh2SLlvtRRoec75z+77jY+OMx+CXnK4EVgREheNMQ+giCJB7P4fAn4FggQB89pdoCTY0JTyWXIuEgIEDAE2B/fMDBL/CEDyF/qMbfgO/wm/AjdDCD6YhfIQBGjkAMJwTywvB59JQCL5LIRrD7244fXDDwe31EATRfL4DaUmEFaELVGApX7lI3wV9x5LEWmRHdeRX2vp+MOC3WCpBcC6tfsu6ihQrEr8I8kMTlmwbJ5oXXCiSxljto/mPcIncxyfgwZkbzRGYRmEIAxQ3Fmf45WQlYiVw8kenHifJYcWiqdlTW6m6pYqDuElnuGR8xbtc1LboDJVgRVZcbNvfSbGKzXb62DyBzJHjADBbhND/GuwoGLQ6HoIQzmAIgym0mR3QdPhXSqw0TcnPcybe8kxtzOFv1xGnWGHT8J/Ovcl2nKwxYyT7+ORX0Q6uxhhXPBxMfTTU32tW/qlxnS6CJQpdP0Bg32asGf2hCYgC/7cIgkFd/KipdThqzXkNsQbcpPDvDnhcCL4SOM+rUe/grzzSe12OtwYWyuTo0DEAhNkKWsbdhJlGz0Xwf1KjYaBfj33/o6rh0a61f0eajDKii+6t8+HFYwom06Jtu18s5tANGsJQGJVSZFQqwmKcpoJIeYjTAM8uJ3fnF+cX55dnpURUJnxDxNZweQ+/E66nwfJ60YwI2WvOMdMvOFFaHDapnW1JM5pwlmqpynw5T0kW2+zYHg/eA89JqBmAzwgGnumm8+99iR48NB1PomUJf6Eif8WCmIls+Dpd85wIzVQSYyUT221DhKScHbtNLi5vLj5NbiuuyYYmxLpOj7i+ur65vftkwrFW6x64Ilm2NbFaG8G7Q49dOHHH1/Dmenx/P/08vrpyZ3fejXfrfp6cGY8KJTCTtdotLpQqSmgiCDZvlhPP8mnn6d175bRDtQ/UebMoqrLul9B+zzfDUxuqJ0n5yqtCGtGqlVG72q+3dbv2/dktJwhvuKDGVjVsR+x+5I3VUGBtuOrroOOuspvsfZJViK4AbSZ6N2uNaTas9RfI46/Mcbxw8bQfETP7lz5DVZZlNlP2GupaLEBFUsenA/rPAAAA//9uhhgAtg0AAA==\"") - packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") + packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXW2/iOBR+z6/wW0ELVUtvM5qnlJhptDR0g7PqPEWexAVrEzvjCy3/fkVCgh2SLlvtRRoec75z+77jY+OMx+CXnK4EVgREheNMQ+giCJB7P4fAn4FggQB89pdoCTY0JTyWXIuEgIEDAE2B/fMDBL/CEDyF/qMbfgO/wm/AjdDCD6YhfIQBGjkAMJwTywvB59JQCL5LIRrD7244fXDDwe31EATRfL4DaUmEFaELVGApX7lI3wV9x5LEWmRHdeRX2vp+MOC3WCpBcC6tfsu6ihQrEr8I8kMTlmwbJ5oXXCiSxljto/mPcIncxyfgwZkbzRGYRmEIAxQ3Fmf45WQlYiVw8kenHifJYcWiqdlTW6m6pYqDuElnuGR8xbtc1LboDJVgRVZcbNvfSbGKzXb62DyBzJHjADBbhND/GuwoGLQ6HoIQzmAIgym0mR3QdPhXSqw0TcnPcybe8kxtzOFv1xGnWGHT8J/Ovcl2nKwxYyT7+ORX0Q6uxhhXPBxMfTTU32tW/qlxnS6CJQpdP0Bg32asGf2hCYgC/7cIgkFd/KipdThqzXkNsQbcpPDvDnhcCL4SOM+rUe/grzzSe12OtwYWyuTo0DEAhNkKWsbdhJlGz0Xwf1KjYaBfj33/o6rh0a61f0eajDKii+6t8+HFYwom06Jtu18s5tANGsJQGJVSZFQqwmKcpoJIeYjTAM8uJ3fnF+cX55dnpURUJnxDxNZweQ+/E66nwfJ60YwI2WvOMdMvOFFaHDapnW1JM5pwlmqpynw5T0kW2+zYHg/eA89JqBmAzwgGnumm8+99iR48NB1PomUJf6Eif8WCmIls+Dpd85wIzVQSYyUT221DhKScHbtNLi5vLj5NbiuuyYYmxLpOj7i+ur65vftkwrFW6x64Ilm2NbFaG8G7Q49dOHHH1/Dmenx/P/08vrpyZ3fejXfrfp6cGY8KJTCTtdotLpQqSmgiCDZvlhPP8mnn6d175bRDtQ/UebMoqrLul9B+zzfDUxuqJ0n5yqtCGtGqlVG72q+3dbv2/dktJwhvuKDGVjVsR+x+5I3VUGBtuOrroOOuspvsfZJViK4AbSZ6N2uNaTas9RfI46/Mcbxw8bQfETP7lz5DVZZlNlP2GupaLEBFUsenA/rPAAAA//9uhhgAtg0AAA==\"") + packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") } diff --git a/internal/context/context.go b/internal/context/context.go index 21bb49a..564e521 100644 --- a/internal/context/context.go +++ b/internal/context/context.go @@ -81,7 +81,7 @@ func NewCContext() (*CContext, error) { } log.Debugf("successfully applied %d migrations to database", numMigrations) - api := models.NewAPICollection(theCtx, sql) + api := models.NewAPICollection(sql) tuners := make(map[int]chan bool) diff --git a/internal/guideproviders/main.go b/internal/guideproviders/main.go index 9054c1d..b89ce70 100644 --- a/internal/guideproviders/main.go +++ b/internal/guideproviders/main.go @@ -1,5 +1,5 @@ // Package guideproviders is a telly internal package to provide electronic program guide (EPG) data. -// It is generally modeled after the XMLTV standard with slight deviations to accomodate other providers. +// It is generally modeled after the XMLTV standard with slight deviations to accommodate other providers. package guideproviders import ( @@ -62,13 +62,13 @@ func (c *Channel) XMLTV() xmltv.Channel { // MythTV seems to assume that the first three display-name elements are // name, callsign and channel number. We follow that scheme here. ch.DisplayNames = []xmltv.CommonElement{ - xmltv.CommonElement{ + { Value: c.Name, }, - xmltv.CommonElement{ + { Value: c.CallSign, }, - xmltv.CommonElement{ + { Value: c.Number, }, } diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 3bf9600..3658678 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -266,7 +266,7 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input } } - outputChannelsMap := make(map[string]interface{}, 0) + outputChannelsMap := make(map[string]interface{}) for shortChannelID, longChannelID := range channelShortToLongIDMap { outputChannelsMap[longChannelID] = channelsCache[shortChannelID] } @@ -288,7 +288,7 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input } // Next, we need to bundle up all the program IDs and request detailed information about them. - neededProgramIDs := make(map[string]struct{}, 0) + neededProgramIDs := make(map[string]struct{}) for _, schedule := range schedules { for _, program := range schedule.Programs { @@ -296,9 +296,9 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input } } - extendedProgramInfo := make(map[string]schedulesdirect.ProgramInfo, 0) + extendedProgramInfo := make(map[string]schedulesdirect.ProgramInfo) - programsWithArtwork := make(map[string]struct{}, 0) + programsWithArtwork := make(map[string]struct{}) // IDs slice is built, let's chunk and get the info. for _, chunk := range utils.ChunkStringSlice(utils.GetStringMapKeys(neededProgramIDs), 5000) { @@ -317,7 +317,7 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input } } - allArtwork := make(map[string][]schedulesdirect.Artwork, 0) + allArtwork := make(map[string][]schedulesdirect.Artwork) // Now that we have the initial program info results, let's get all the artwork. artworkResp, artworkErr := s.client.GetArtworkForProgramIDs(utils.GetStringMapKeys(programsWithArtwork)) @@ -598,7 +598,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program // Now for the fields that have to be parsed. for _, broadcastLang := range station.Station.BroadcastLanguage { - xmlProgramme.Languages = []xmltv.CommonElement{xmltv.CommonElement{ + xmlProgramme.Languages = []xmltv.CommonElement{{ Value: broadcastLang, Lang: broadcastLang, }} @@ -612,7 +612,7 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program } if programInfo.EpisodeTitle150 != "" { - xmlProgramme.SecondaryTitles = []xmltv.CommonElement{xmltv.CommonElement{ + xmlProgramme.SecondaryTitles = []xmltv.CommonElement{{ Value: programInfo.EpisodeTitle150, }} } @@ -860,59 +860,57 @@ func getDaysBetweenTimes(start, end time.Time) []string { type artworkTierOrder int const ( - EpisodeTier artworkTierOrder = 1 - SeasonTier artworkTierOrder = 2 - SeriesTier artworkTierOrder = 3 + episodeTier artworkTierOrder = 1 + seasonTier artworkTierOrder = 2 + seriesTier artworkTierOrder = 3 - DontCareTier artworkTierOrder = 10 + dontCareTier artworkTierOrder = 10 ) func parseArtworkTierToOrder(tier schedulesdirect.ArtworkTier) artworkTierOrder { switch tier { case schedulesdirect.EpisodeTier: - return EpisodeTier + return episodeTier case schedulesdirect.SeasonTier: - return SeasonTier + return seasonTier case schedulesdirect.SeriesTier: - return SeriesTier + return seriesTier default: - return DontCareTier + return dontCareTier } - - return DontCareTier } type artworkCategoryOrder int const ( - BannerL1 artworkCategoryOrder = 1 - BannerL1T artworkCategoryOrder = 2 - Banner artworkCategoryOrder = 3 - BannerL2 artworkCategoryOrder = 4 - BannerL3 artworkCategoryOrder = 5 - BannerLO artworkCategoryOrder = 6 - BannerLOT artworkCategoryOrder = 7 - - DontCareCategory artworkCategoryOrder = 10 + bannerL1 artworkCategoryOrder = 1 + bannerL1T artworkCategoryOrder = 2 + banner artworkCategoryOrder = 3 + bannerL2 artworkCategoryOrder = 4 + bannerL3 artworkCategoryOrder = 5 + bannerLO artworkCategoryOrder = 6 + bannerLOT artworkCategoryOrder = 7 + + dontCareCategory artworkCategoryOrder = 10 ) func parseArtworkCategoryToOrder(Category schedulesdirect.ArtworkCategory) artworkCategoryOrder { switch Category { case schedulesdirect.BannerL1: - return BannerL1 + return bannerL1 case schedulesdirect.BannerL1T: - return BannerL1T + return bannerL1T case schedulesdirect.Banner: - return Banner + return banner case schedulesdirect.BannerL2: - return BannerL2 + return bannerL2 case schedulesdirect.BannerL3: - return BannerL3 + return bannerL3 case schedulesdirect.BannerLO: - return BannerLO + return bannerLO case schedulesdirect.BannerLOT: - return BannerLOT + return bannerLOT } - return DontCareCategory + return dontCareCategory } diff --git a/internal/guideproviders/xmltv.go b/internal/guideproviders/xmltv.go index 340baf8..2204429 100644 --- a/internal/guideproviders/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -85,7 +85,7 @@ func (x *XMLTV) Schedule(daysToGet int, inputChannels []Channel, inputProgrammes // Refresh causes the provider to request the latest information. func (x *XMLTV) Refresh(lineupStateJSON []byte) ([]byte, error) { - xTV, xTVErr := utils.GetXMLTV(x.BaseConfig.XMLTVURL, false) + xTV, xTVErr := utils.GetXMLTV(x.BaseConfig.XMLTVURL) if xTVErr != nil { return nil, fmt.Errorf("error when getting XMLTV file: %s", xTVErr) } diff --git a/internal/metrics/metrics.go b/internal/metrics/metrics.go index 6f4beb1..1619563 100644 --- a/internal/metrics/metrics.go +++ b/internal/metrics/metrics.go @@ -61,6 +61,7 @@ var ( ) ) +// nolint func init() { version.NewCollector("telly") prometheus.MustRegister(ExposedChannels) diff --git a/internal/models/guide_source.go b/internal/models/guide_source.go index 480217c..99d4282 100644 --- a/internal/models/guide_source.go +++ b/internal/models/guide_source.go @@ -7,6 +7,7 @@ import ( "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/guideproviders" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // GuideSourceDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -107,7 +108,11 @@ func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource, provid // GetGuideSourceByID returns a single GuideSource for the given ID. func (db *GuideSourceDB) GetGuideSourceByID(id int) (*GuideSource, error) { var guideSource GuideSource - err := db.SQL.Get(&guideSource, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceQuery), id) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source").Where(squirrel.Eq{"id": id}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Get(&guideSource, sql, args) return &guideSource, err } diff --git a/internal/models/guide_source_channel.go b/internal/models/guide_source_channel.go index 3dab30a..564125e 100644 --- a/internal/models/guide_source_channel.go +++ b/internal/models/guide_source_channel.go @@ -8,6 +8,7 @@ import ( "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/internal/xmltv" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // GuideSourceChannelDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -54,6 +55,7 @@ type GuideSourceChannelAPI interface { GetChannelsForGuideSource(guideSourceID int) ([]GuideSourceChannel, error) } +// nolint const baseGuideSourceChannelQuery string = ` SELECT G.id, @@ -106,7 +108,11 @@ func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel gu // GetGuideSourceChannelByID returns a single GuideSourceChannel for the given ID. func (db *GuideSourceChannelDB) GetGuideSourceChannelByID(id int, expanded bool) (*GuideSourceChannel, error) { var channel GuideSourceChannel - err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceChannelQuery), id) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_channel").Where(squirrel.Eq{"id": id}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Get(&channel, sql, args) if err != nil { return nil, err } @@ -136,6 +142,10 @@ func (db *GuideSourceChannelDB) UpdateGuideSourceChannel(XMLTVID string, provide // GetChannelsForGuideSource returns a slice of GuideSourceChannels for the given video source ID. func (db *GuideSourceChannelDB) GetChannelsForGuideSource(guideSourceID int) ([]GuideSourceChannel, error) { channels := make([]GuideSourceChannel, 0) - err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE G.guide_id = $1`, baseGuideSourceChannelQuery), guideSourceID) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_channel").Where(squirrel.Eq{"guide_id": guideSourceID}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Select(&channels, sql, args) return channels, err } diff --git a/internal/models/guide_source_programme.go b/internal/models/guide_source_programme.go index fb859ef..9730116 100644 --- a/internal/models/guide_source_programme.go +++ b/internal/models/guide_source_programme.go @@ -7,6 +7,7 @@ import ( "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/xmltv" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // GuideSourceProgrammeDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -56,6 +57,7 @@ type GuideSourceProgrammeAPI interface { GetProgrammesForGuideID(guideSourceID int) ([]GuideSourceProgramme, error) } +// nolint const baseGuideSourceProgrammeQuery string = ` SELECT G.guide_id, @@ -114,14 +116,18 @@ func (db *GuideSourceProgrammeDB) InsertGuideSourceProgramme(guideID int, progra // GetGuideSourceProgrammeByID returns a single GuideSourceProgramme for the given ID. func (db *GuideSourceProgrammeDB) GetGuideSourceProgrammeByID(id int) (*GuideSourceProgramme, error) { var programme GuideSourceProgramme - err := db.SQL.Get(&programme, fmt.Sprintf(`%s WHERE G.id = $1`, baseGuideSourceProgrammeQuery), id) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(squirrel.Eq{"id": id}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Get(&programme, sql, args) if err != nil { return nil, err } return &programme, err } -// DeleteGuideSourceProgramme marks a programme with the given ID as deleted. +// DeleteGuideSourceProgrammesForChannel marks a programme with the given ID as deleted. func (db *GuideSourceProgrammeDB) DeleteGuideSourceProgrammesForChannel(channelID string) error { _, err := db.SQL.Exec(`DELETE FROM guide_source_programme WHERE channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel WHERE id = ?))`, channelID) return err @@ -136,7 +142,11 @@ func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID string, // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) ORDER BY start ASC`, baseGuideSourceProgrammeQuery)) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("WHERE G.channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) ORDER BY start ASC").ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Select(&programmes, sql, args) if err != nil { return nil, err } @@ -152,7 +162,11 @@ func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourc // GetProgrammesForChannel returns a slice of GuideSourceProgrammes for the given XMLTV channel ID. func (db *GuideSourceProgrammeDB) GetProgrammesForChannel(channelID string) ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.channel = $1 AND G.start >= datetime('now') AND G.start <= datetime('now', '+6 hours')`, baseGuideSourceProgrammeQuery), channelID) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(squirrel.And{squirrel.Eq{"channel": channelID}, squirrel.GtOrEq{"start": "datetime('now')"}, squirrel.LtOrEq{"start": "datetime('now', '+6 hours')"}}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Select(&programmes, sql, args) if err != nil { return nil, err } @@ -168,7 +182,11 @@ func (db *GuideSourceProgrammeDB) GetProgrammesForChannel(channelID string) ([]G // GetProgrammesForGuideID returns a slice of GuideSourceProgrammes for the given guide ID. func (db *GuideSourceProgrammeDB) GetProgrammesForGuideID(guideSourceID int) ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - err := db.SQL.Select(&programmes, fmt.Sprintf(`%s WHERE G.guide_id = $1 AND G.start >= datetime('now') AND G.start <= datetime('now', '+6 hours')`, baseGuideSourceProgrammeQuery), guideSourceID) + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(squirrel.And{squirrel.Eq{"guide_id": guideSourceID}, squirrel.GtOrEq{"start": "datetime('now')"}, squirrel.LtOrEq{"start": "datetime('now', '+6 hours')"}}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Select(&programmes, sql, args) if err != nil { return nil, err } diff --git a/internal/models/lineup.go b/internal/models/lineup.go index 07f8773..227ed8d 100644 --- a/internal/models/lineup.go +++ b/internal/models/lineup.go @@ -10,6 +10,7 @@ import ( upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/jmoiron/sqlx" "github.com/satori/go.uuid" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // LineupDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -201,7 +202,11 @@ func (db *LineupDB) InsertLineup(lineupStruct Lineup) (*Lineup, error) { // GetLineupByID returns a single Lineup for the given ID. func (db *LineupDB) GetLineupByID(id int, withChannels bool) (*Lineup, error) { var lineup Lineup - err := db.SQL.Get(&lineup, fmt.Sprintf(`%s WHERE L.id = $1`, baseLineupQuery), id) + sql, args, sqlGenErr := squirrel.Select("*").From("lineup").Where(squirrel.Eq{"id": id}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Get(&lineup, sql, args) if withChannels { channels, channelsErr := db.Collection.LineupChannel.GetChannelsForLineup(lineup.ID, true) if channelsErr != nil { diff --git a/internal/models/lineup_channel.go b/internal/models/lineup_channel.go index f36910e..bc20e27 100644 --- a/internal/models/lineup_channel.go +++ b/internal/models/lineup_channel.go @@ -6,6 +6,7 @@ import ( "time" "github.com/jmoiron/sqlx" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // LineupChannelDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -117,6 +118,7 @@ type LineupChannelAPI interface { GetEnabledChannelsForVideoProvider(providerID int) ([]LineupChannel, error) } +// nolint const baseLineupChannelQuery string = ` SELECT C.id, @@ -158,7 +160,13 @@ func (db *LineupChannelDB) UpsertLineupChannel(channelStruct LineupChannel) (*Li // GetLineupChannelByID returns a single LineupChannel for the given ID. func (db *LineupChannelDB) GetLineupChannelByID(lineupID int, channelNumber string) (*LineupChannel, error) { var channel LineupChannel - err := db.SQL.Get(&channel, fmt.Sprintf(`%s WHERE C.lineup_id = $1 AND C.channel_number = $2`, baseLineupChannelQuery), lineupID, channelNumber) + + sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(squirrel.Eq{"lineup_id": lineupID, "channel_number": channelNumber}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + + err := db.SQL.Get(&channel, sql, args) if err != nil { return nil, err } @@ -188,7 +196,11 @@ func (db *LineupChannelDB) UpdateLineupChannel(channelStruct LineupChannel) (*Li // GetChannelsForLineup returns a slice of LineupChannels for the given lineup ID. func (db *LineupChannelDB) GetChannelsForLineup(lineupID int, expanded bool) ([]LineupChannel, error) { channels := make([]LineupChannel, 0) - err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE C.lineup_id = $1`, baseLineupChannelQuery), lineupID) + sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(squirrel.Eq{"lineup_id": lineupID}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + err := db.SQL.Select(&channels, sql, args) if err != nil { return nil, err } @@ -210,7 +222,16 @@ func (db *LineupChannelDB) GetChannelsForLineup(lineupID int, expanded bool) ([] // GetEnabledChannelsForGuideProvider returns a slice of LineupChannels for the given guide provider ID. func (db *LineupChannelDB) GetEnabledChannelsForGuideProvider(providerID int) ([]LineupChannel, error) { channels := make([]LineupChannel, 0) - err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE C.guide_channel_id IN (SELECT id FROM guide_source_channel WHERE guide_id = $1)`, baseLineupChannelQuery), providerID) + + inQuery := squirrel.Select("id").From("guide_source_channel").Where(squirrel.Eq{"guide_id": providerID}) + + // Using DebugSqlizer is unsafe but Squirrel doesn't support WHERE IN subqueries. + sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(squirrel.Eq{"guide_channel_id": squirrel.DebugSqlizer(inQuery)}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + + err := db.SQL.Select(&channels, sql, args) if err != nil { return nil, err } @@ -230,7 +251,16 @@ func (db *LineupChannelDB) GetEnabledChannelsForGuideProvider(providerID int) ([ // GetEnabledChannelsForVideoProvider returns a slice of LineupChannels for the given video provider ID. func (db *LineupChannelDB) GetEnabledChannelsForVideoProvider(providerID int) ([]LineupChannel, error) { channels := make([]LineupChannel, 0) - err := db.SQL.Select(&channels, fmt.Sprintf(`%s WHERE C.video_track_id IN (SELECT id FROM video_source_track WHERE video_source_id = $1)`, baseLineupChannelQuery), providerID) + + inQuery := squirrel.Select("id").From("video_source_track").Where(squirrel.Eq{"video_source_id": providerID}) + + // Using DebugSqlizer is unsafe but Squirrel doesn't support WHERE IN subqueries. + sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(squirrel.Eq{"video_track_id": squirrel.DebugSqlizer(inQuery)}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + + err := db.SQL.Select(&channels, sql, args) if err != nil { return nil, err } diff --git a/internal/models/main.go b/internal/models/main.go index 62e0bc7..f6ffefa 100644 --- a/internal/models/main.go +++ b/internal/models/main.go @@ -1,11 +1,11 @@ package models import ( - "context" "os" "github.com/jmoiron/sqlx" "github.com/sirupsen/logrus" + "gopkg.in/Masterminds/squirrel.v1" ) var ( @@ -19,6 +19,8 @@ var ( } ) +var sq = squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar) // nolint + // APICollection is a struct containing all models. type APICollection struct { GuideSource GuideSourceAPI @@ -31,7 +33,7 @@ type APICollection struct { } // NewAPICollection returns an initialized APICollection struct. -func NewAPICollection(ctx context.Context, db *sqlx.DB) *APICollection { +func NewAPICollection(db *sqlx.DB) *APICollection { api := &APICollection{} api.GuideSource = newGuideSourceDB(db, api) diff --git a/internal/models/video_source.go b/internal/models/video_source.go index 4854135..cc34fd1 100644 --- a/internal/models/video_source.go +++ b/internal/models/video_source.go @@ -1,11 +1,11 @@ package models import ( - "fmt" "time" "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/videoproviders" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // VideoSourceDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -100,7 +100,13 @@ func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*Vide // GetVideoSourceByID returns a single VideoSource for the given ID. func (db *VideoSourceDB) GetVideoSourceByID(id int) (*VideoSource, error) { var videoSource VideoSource - err := db.SQL.Get(&videoSource, fmt.Sprintf(`%s WHERE V.id = $1`, baseVideoSourceQuery), id) + + sql, args, sqlGenErr := squirrel.Select("*").From("video_source").Where(squirrel.Eq{"id": id}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + + err := db.SQL.Get(&videoSource, sql, args) return &videoSource, err } diff --git a/internal/models/video_source_track.go b/internal/models/video_source_track.go index d3829cc..f497250 100644 --- a/internal/models/video_source_track.go +++ b/internal/models/video_source_track.go @@ -1,10 +1,10 @@ package models import ( - "fmt" "time" "github.com/jmoiron/sqlx" + squirrel "gopkg.in/Masterminds/squirrel.v1" ) // VideoSourceTrackDB is a struct containing initialized the SQL connection as well as the APICollection. @@ -53,6 +53,7 @@ type VideoSourceTrackAPI interface { GetTracksForVideoSource(videoSourceID int) ([]VideoSourceTrack, error) } +// nolint const baseVideoSourceTrackQuery string = ` SELECT T.id, @@ -86,7 +87,13 @@ func (db *VideoSourceTrackDB) InsertVideoSourceTrack(trackStruct VideoSourceTrac // GetVideoSourceTrackByID returns a single VideoSourceTrack for the given ID. func (db *VideoSourceTrackDB) GetVideoSourceTrackByID(id int, expanded bool) (*VideoSourceTrack, error) { var track VideoSourceTrack - err := db.SQL.Get(&track, fmt.Sprintf(`%s WHERE T.id = $1`, baseVideoSourceTrackQuery), id) + + sql, args, sqlGenErr := squirrel.Select("*").From("video_source_track").Where(squirrel.Eq{"id": id}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + + err := db.SQL.Get(&track, sql, args) if expanded { video, videoErr := db.Collection.VideoSource.GetVideoSourceByID(track.VideoSourceID) if videoErr != nil { @@ -114,6 +121,12 @@ func (db *VideoSourceTrackDB) UpdateVideoSourceTrack(trackID int, description st // GetTracksForVideoSource returns a slice of VideoSourceTracks for the given video source ID. func (db *VideoSourceTrackDB) GetTracksForVideoSource(videoSourceID int) ([]VideoSourceTrack, error) { tracks := make([]VideoSourceTrack, 0) - err := db.SQL.Select(&tracks, fmt.Sprintf(`%s WHERE T.video_source_id = $1`, baseVideoSourceTrackQuery), videoSourceID) + + sql, args, sqlGenErr := squirrel.Select("*").From("video_source_track").Where(squirrel.Eq{"video_source_id": videoSourceID}).ToSql() + if sqlGenErr != nil { + return nil, sqlGenErr + } + + err := db.SQL.Select(&tracks, sql, args) return tracks, err } diff --git a/internal/streamsuite/stream.go b/internal/streamsuite/stream.go index 7cf50f6..47f5d5d 100644 --- a/internal/streamsuite/stream.go +++ b/internal/streamsuite/stream.go @@ -27,9 +27,11 @@ var ( ) const ( + // BufferSize is the size of the content buffer we will use. BufferSize = 1024 * 8 ) +// Stream describes a single active video stream in telly. type Stream struct { UUID string Channel *models.LineupChannel @@ -46,6 +48,7 @@ type Stream struct { LastWroteAt *time.Time } +// Start will mark the stream as playing and begin playback. func (s *Stream) Start(c *gin.Context) { now := time.Now() s.LastWroteAt = &now @@ -91,7 +94,7 @@ func (s *Stream) Start(c *gin.Context) { } // We wait at least 2 full seconds before declaring that a stream is paused. - if time.Now().Sub(*s.LastWroteAt) > 2*time.Second { + if time.Since(*s.LastWroteAt) > 2*time.Second { s.Pause() } } @@ -147,6 +150,7 @@ forLoop: } +// Pause will cause the stream to pause playback. func (s *Stream) Pause() { if !s.Paused { s.Paused = true @@ -157,6 +161,7 @@ func (s *Stream) Pause() { } } +// Unpause will resume playback. func (s *Stream) Unpause(increaseActiveStreams bool) { if s.Paused { s.Paused = false @@ -168,6 +173,7 @@ func (s *Stream) Unpause(increaseActiveStreams bool) { } } +// Stop will tear down the stream. func (s *Stream) Stop() { if s.Paused { metrics.PausedStreams.WithLabelValues(s.PromLabels...).Dec() diff --git a/internal/streamsuite/transports.go b/internal/streamsuite/transports.go index ee319e8..3ed3130 100644 --- a/internal/streamsuite/transports.go +++ b/internal/streamsuite/transports.go @@ -10,6 +10,7 @@ import ( "github.com/prometheus/common/version" ) +// StreamTransport is a method to acquire a video source. type StreamTransport interface { Type() string Headers() http.Header @@ -17,25 +18,30 @@ type StreamTransport interface { Stop() error } +// FFMPEG is a transport that uses FFMPEG to process the video stream. type FFMPEG struct { run *exec.Cmd } +// MarshalJSON returns the string type of transport. func (f FFMPEG) MarshalJSON() ([]byte, error) { return json.Marshal(f.Type()) } +// Type describes the type of transport. func (f FFMPEG) Type() string { return "FFMPEG" } +// Headers returns HTTP headers to add to the outbound request, if any. func (f FFMPEG) Headers() http.Header { return nil } +// Start will begin the stream. func (f FFMPEG) Start(streamURL string) (io.ReadCloser, error) { log.Infoln("Transcoding stream with ffmpeg") - f.run = exec.Command("ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") + f.run = exec.Command("ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") // nolint streamData, stdErr := f.run.StdoutPipe() if stdErr != nil { return nil, stdErr @@ -48,23 +54,28 @@ func (f FFMPEG) Start(streamURL string) (io.ReadCloser, error) { return streamData, nil } +// Stop kills the stream func (f FFMPEG) Stop() error { return f.run.Process.Kill() } +// HTTP is a transport that simply "restreams" the video from the source with a small buffer. type HTTP struct { req *http.Request resp *http.Response } +// MarshalJSON returns the string type of transport. func (h HTTP) MarshalJSON() ([]byte, error) { return json.Marshal(h.Type()) } +// Type describes the type of transport. func (h HTTP) Type() string { return "HTTP" } +// Headers returns HTTP headers to add to the outbound request, if any. func (h HTTP) Headers() http.Header { if h.resp == nil { return nil @@ -72,7 +83,8 @@ func (h HTTP) Headers() http.Header { return h.resp.Header } -func (h HTTP) Start(streamURL string) (io.ReadCloser, error) { +// Start will begin the stream. +func (h *HTTP) Start(streamURL string) (io.ReadCloser, error) { streamReq, reqErr := http.NewRequest("GET", streamURL, nil) if reqErr != nil { return nil, reqErr @@ -96,6 +108,7 @@ func (h HTTP) Start(streamURL string) (io.ReadCloser, error) { return resp.Body, nil } +// Stop kills the stream func (h HTTP) Stop() error { return nil } diff --git a/internal/utils/main.go b/internal/utils/main.go index b87f8ff..d99d8fe 100644 --- a/internal/utils/main.go +++ b/internal/utils/main.go @@ -47,10 +47,10 @@ func GetTCPAddr(key string) *net.TCPAddr { } // GetM3U is a helper function to download/open and parse a M3U Plus file. -func GetM3U(path string, cacheFiles bool) (*m3uplus.Playlist, error) { +func GetM3U(path string) (*m3uplus.Playlist, error) { // safePath := SafeStringsRegex.ReplaceAllStringFunc(path, StringSafer) - file, _, err := GetFile(path, cacheFiles) + file, _, err := GetFile(path) if err != nil { return nil, fmt.Errorf("error while opening m3u file: %s", err) } @@ -68,10 +68,10 @@ func GetM3U(path string, cacheFiles bool) (*m3uplus.Playlist, error) { } // GetXMLTV is a helper function to download/open and parse a XMLTV file. -func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { +func GetXMLTV(path string) (*xmltv.TV, error) { // safePath := SafeStringsRegex.ReplaceAllStringFunc(path, StringSafer) - file, _, err := GetFile(path, cacheFiles) + file, _, err := GetFile(path) if err != nil { return nil, err } @@ -90,7 +90,7 @@ func GetXMLTV(path string, cacheFiles bool) (*xmltv.TV, error) { } // GetFile is a helper function to download/open and parse a file. -func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { +func GetFile(path string) (io.ReadCloser, string, error) { transport := "disk" if strings.HasPrefix(strings.ToLower(path), "http") { @@ -105,7 +105,7 @@ func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { // For whatever reason, some providers only allow access from a "real" User-Agent. req.Header.Set("User-Agent", "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_13_6) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/68.0.3440.106 Safari/537.36") - resp, err := http.Get(path) + resp, err := http.Get(path) // nolint if err != nil { return nil, transport, err } @@ -117,21 +117,13 @@ func GetFile(path string, cacheFiles bool) (io.ReadCloser, string, error) { return nil, transport, gzErr } - if cacheFiles { - return writeFile(path, transport, gz) - } - return gz, transport, nil } - if cacheFiles { - return writeFile(path, transport, resp.Body) - } - return resp.Body, transport, nil } - file, fileErr := os.Open(path) + file, fileErr := os.Open(path) // nolint if fileErr != nil { return nil, transport, fileErr } @@ -155,13 +147,6 @@ func ChunkStringSlice(sl []string, chunkSize int) [][]string { return divided } -func writeFile(path, transport string, reader io.ReadCloser) (io.ReadCloser, string, error) { - // buf := new(bytes.Buffer) - // buf.ReadFrom(reader) - // buf.Bytes() - return reader, transport, nil -} - // Contains returns true if the given element "e" is found inside the slice of strings "s". func Contains(s []string, e string) bool { for _, ss := range s { @@ -223,15 +208,15 @@ func toLower(ch rune) rune { return ch } -// isLower checks if a character is upper case. More precisely it evaluates if it is +// isUpper checks if a character is upper case. More precisely it evaluates if it is // in the range of ASCII characters 'A' to 'Z'. func isUpper(ch rune) bool { return ch >= 'A' && ch <= 'Z' } -// toLower converts a character in the range of ASCII characters 'a' to 'z' to its lower +// toUpper converts a character in the range of ASCII characters 'a' to 'z' to its lower // case counterpart. Other characters remain the same. -func toUpper(ch rune) rune { +func toUpper(ch rune) rune { // nolint if ch >= 'a' && ch <= 'z' { return ch - 32 } diff --git a/internal/videoproviders/m3u.go b/internal/videoproviders/m3u.go index a5a691c..372b66f 100644 --- a/internal/videoproviders/m3u.go +++ b/internal/videoproviders/m3u.go @@ -63,7 +63,7 @@ func (m *M3U) StreamURL(streamID int, wantedFormat string) (string, error) { // Refresh causes the provider to request the latest information. func (m *M3U) Refresh() error { - playlist, m3uErr := utils.GetM3U(m.BaseConfig.M3UURL, false) + playlist, m3uErr := utils.GetM3U(m.BaseConfig.M3UURL) if m3uErr != nil { return fmt.Errorf("error when reading m3u: %s", m3uErr) } @@ -130,7 +130,7 @@ func (m *M3U) Refresh() error { Name: nameVal, StreamID: channelID, Logo: logoVal, - Type: ChannelType(LiveStream), + Type: LiveStream, Category: categoryVal, EPGID: epgIDVal, diff --git a/internal/videoproviders/main.go b/internal/videoproviders/main.go index afd5839..7001cec 100644 --- a/internal/videoproviders/main.go +++ b/internal/videoproviders/main.go @@ -7,9 +7,10 @@ import ( ) var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch -var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString -var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString -var hdRegex = regexp.MustCompile(`hd|4k`) + +// var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString +// var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString +// var hdRegex = regexp.MustCompile(`hd|4k`) // Configuration is the basic configuration struct for videoproviders with generic values for specific providers. type Configuration struct { diff --git a/internal/xmltv/xmltv.go b/internal/xmltv/xmltv.go index f4e433d..cc8cc51 100644 --- a/internal/xmltv/xmltv.go +++ b/internal/xmltv/xmltv.go @@ -4,7 +4,7 @@ package xmltv import ( "encoding/xml" "fmt" - "os" + "io" "strings" "time" @@ -111,16 +111,12 @@ type TV struct { } // LoadXML loads the XMLTV XML from file. -func (t *TV) LoadXML(f *os.File) error { +func (t *TV) LoadXML(f io.Reader) error { decoder := xml.NewDecoder(f) decoder.CharsetReader = charset.NewReaderLabel err := decoder.Decode(&t) - if err != nil { - return err - } - - return nil + return err } // Channel details of a channel diff --git a/internal/xmltv/xmltv_test.go b/internal/xmltv/xmltv_test.go index fcad44f..f54a6b1 100644 --- a/internal/xmltv/xmltv_test.go +++ b/internal/xmltv/xmltv_test.go @@ -42,30 +42,30 @@ func TestDecode(t *testing.T) { XMLName: xml.Name{Space: "", Local: "channel"}, ID: "I10436.labs.zap2it.com", DisplayNames: []CommonElement{ - CommonElement{ + { Value: "13 KERA", }, - CommonElement{ + { Value: "13 KERA TX42822:-", }, - CommonElement{ + { Value: "13", }, - CommonElement{ + { Value: "13 KERA fcc", }, - CommonElement{ + { Value: "KERA", }, - CommonElement{ + { Value: "KERA", }, - CommonElement{ + { Value: "PBS Affiliate", }, }, Icons: []Icon{ - Icon{ + { Source: `file://C:\Perl\site/share/xmltv/icons/KERA.gif`, }, }, @@ -84,41 +84,41 @@ func TestDecode(t *testing.T) { Start: &Time{time.Date(2008, 07, 15, 0, 30, 0, 0, loc)}, Stop: &Time{time.Date(2008, 07, 15, 1, 0, 0, 0, loc)}, Titles: []CommonElement{ - CommonElement{ + { Lang: "en", Value: "NOW on PBS", }, }, Descriptions: []CommonElement{ - CommonElement{ + { Lang: "en", Value: "Jordan's Queen Rania has made job creation a priority to help curb the staggering unemployment rates among youths in the Middle East.", }, }, Categories: []CommonElement{ - CommonElement{ + { Lang: "en", Value: "Newsmagazine", }, - CommonElement{ + { Lang: "en", Value: "Interview", }, - CommonElement{ + { Lang: "en", Value: "Public affairs", }, - CommonElement{ + { Lang: "en", Value: "Series", }, }, EpisodeNums: []EpisodeNum{ - EpisodeNum{ + { System: "dd_progid", Value: "EP01006886.0028", }, - EpisodeNum{ + { System: "onscreen", Value: "427", }, @@ -130,7 +130,7 @@ func TestDecode(t *testing.T) { Start: Time{time.Date(2008, 07, 11, 0, 0, 0, 0, time.UTC)}, }, Subtitles: []Subtitle{ - Subtitle{ + { Type: "teletext", }, }, diff --git a/main.go b/main.go index 010a269..1834268 100644 --- a/main.go +++ b/main.go @@ -20,9 +20,8 @@ import ( ) var ( - namespace = "telly" - namespaceWithVersion = fmt.Sprintf("%s %s", namespace, version.Version) - log = &logrus.Logger{ + namespace = "telly" + log = &logrus.Logger{ Out: os.Stderr, Formatter: &logrus.TextFormatter{ FullTimestamp: true, @@ -119,12 +118,16 @@ func main() { for _, videoSource := range videoProviders { commands.StartFireVideoUpdates(cc, videoSource) - c.AddFunc(videoSource.UpdateFrequency, func() { commands.StartFireVideoUpdates(cc, videoSource) }) + if addErr := c.AddFunc(videoSource.UpdateFrequency, func() { commands.StartFireVideoUpdates(cc, videoSource) }); addErr != nil { + log.WithError(addErr).Errorln("error when adding video source to scheduled background jobs") + } } for _, guideSource := range guideProviders { commands.StartFireGuideUpdates(cc, guideSource) - c.AddFunc(guideSource.UpdateFrequency, func() { commands.StartFireGuideUpdates(cc, guideSource) }) + if addErr := c.AddFunc(guideSource.UpdateFrequency, func() { commands.StartFireGuideUpdates(cc, guideSource) }); addErr != nil { + log.WithError(addErr).Errorln("error when adding guide source to scheduled background jobs") + } } } From d1bac6a6868433df54845184788ccab2433988ed Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:15:57 -0700 Subject: [PATCH 121/182] Add Squirrel to dep --- Gopkg.lock | 25 +++++++++++++++++++++++++ Gopkg.toml | 4 ++++ 2 files changed, 29 insertions(+) diff --git a/Gopkg.lock b/Gopkg.lock index 143e87e..c91340b 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -146,6 +146,22 @@ revision = "e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f" version = "v0.1.0" +[[projects]] + branch = "master" + digest = "1:a7fc52742a5d011497b6a24024c857d260f809083424cd84110c9e40c34f64fc" + name = "github.com/lann/builder" + packages = ["."] + pruneopts = "UT" + revision = "47ae307949d02aa1f1069fdafc00ca08e1dbabac" + +[[projects]] + branch = "master" + digest = "1:225499d25a9f1486f3b77cdc4f7d6590c506c3839bb9d8497113f6d19676d54a" + name = "github.com/lann/ps" + packages = ["."] + pruneopts = "UT" + revision = "62de8c46ede02a7675c4c79c84883eb164cb71e3" + [[projects]] digest = "1:c568d7727aa262c32bdf8a3f7db83614f7af0ed661474b24588de635c20024c7" name = "github.com/magiconair/properties" @@ -428,6 +444,14 @@ revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" version = "v0.3.0" +[[projects]] + digest = "1:3ca2109e48660e527509b433c4efb5b910e5b9010d5149a6f44137d47b7970ca" + name = "gopkg.in/Masterminds/squirrel.v1" + packages = ["."] + pruneopts = "UT" + revision = "a6b93000bd219143c56c16e6cb1c4b91da3f224b" + version = "v1.0" + [[projects]] digest = "1:1b4724d3c8125f6044925f02b485b74bfec9905cbf579d95aafd1a6c8f8447d3" name = "gopkg.in/go-playground/validator.v8" @@ -478,6 +502,7 @@ "github.com/tellytv/go.xtream-codes", "github.com/zsais/go-gin-prometheus", "golang.org/x/net/html/charset", + "gopkg.in/Masterminds/squirrel.v1", ] solver-name = "gps-cdcl" solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml index 6167e7c..f755d40 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -113,6 +113,10 @@ branch = "master" name = "golang.org/x/net" +[[constraint]] + name = "github.com/Masterminds/squirrel" + version = "1.0" + [prune] go-tests = true unused-packages = true From 2d6e2522e1d7de87f810ef338a414ce369fc365d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:17:42 -0700 Subject: [PATCH 122/182] combine gometalinter calls --- Makefile | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Makefile b/Makefile index b780682..e310b2e 100644 --- a/Makefile +++ b/Makefile @@ -18,8 +18,7 @@ all: style dep build test style: @echo ">> checking code style" @$(GO) get -u github.com/alecthomas/gometalinter - @$(GOMETALINTER_BINARY) --config=.gometalinter.json --install - @$(GOMETALINTER_BINARY) --config=.gometalinter.json ./... + @$(GOMETALINTER_BINARY) --config=.gometalinter.json --install ./... dep: $(DEP_BINARY) @echo ">> installing dependencies" From 14796227dc26fb6ab9af86f43c695e7309eef9a3 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:18:31 -0700 Subject: [PATCH 123/182] dep needs to happen before anything else --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index e310b2e..b15f8e4 100644 --- a/Makefile +++ b/Makefile @@ -13,7 +13,7 @@ DOCKER_IMAGE_NAME ?= telly DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD)) -all: style dep build test +all: dep style build test style: @echo ">> checking code style" From 6a0fc7e718fbf12fbd1e9c9c23efc05093d144d9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:20:03 -0700 Subject: [PATCH 124/182] curl dep before make --- .circleci/config.yml | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index e3e185c..e7ae391 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -10,6 +10,7 @@ jobs: steps: - checkout - setup_remote_docker + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: make promu - run: make @@ -19,8 +20,8 @@ jobs: steps: - checkout - - run: make promu - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: make promu - run: make dep - run: promu crossbuild -v - persist_to_workspace: @@ -38,6 +39,7 @@ jobs: - setup_remote_docker - attach_workspace: at: . + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: ln -s .build/linux-amd64/telly telly - run: make docker - run: docker images @@ -57,8 +59,8 @@ jobs: - run: echo 'export PATH=${HOME}/bin:${PATH}' >> ${BASH_ENV} - attach_workspace: at: . - - run: make promu - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: make promu - run: make dep - run: promu crossbuild tarballs - run: promu checksum .tarballs From cfc6a81568aad1efc86f93eff9552113f4ce9fdb Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:25:51 -0700 Subject: [PATCH 125/182] test running build in docker --- .circleci/config.yml | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index e7ae391..2ff80ac 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -15,8 +15,11 @@ jobs: - run: make build: - machine: true - working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly + # machine: true + # working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly + docker: + - image: circleci/golang:1.10 + working_directory: /go/src/github.com/tellytv/telly steps: - checkout From 9f520ecaa0d7df1c1c421bce31b10e557a6a12da Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:28:33 -0700 Subject: [PATCH 126/182] Revert "test running build in docker" This reverts commit cfc6a81568aad1efc86f93eff9552113f4ce9fdb. --- .circleci/config.yml | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 2ff80ac..e7ae391 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -15,11 +15,8 @@ jobs: - run: make build: - # machine: true - # working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly - docker: - - image: circleci/golang:1.10 - working_directory: /go/src/github.com/tellytv/telly + machine: true + working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly steps: - checkout From ef20d919660b953073547bb58266048f3f380d2d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:31:37 -0700 Subject: [PATCH 127/182] set install directory --- .circleci/config.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index e7ae391..40b4bcf 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -10,7 +10,7 @@ jobs: steps: - checkout - setup_remote_docker - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: make promu - run: make @@ -20,7 +20,7 @@ jobs: steps: - checkout - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: make promu - run: make dep - run: promu crossbuild -v @@ -39,7 +39,7 @@ jobs: - setup_remote_docker - attach_workspace: at: . - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: ln -s .build/linux-amd64/telly telly - run: make docker - run: docker images @@ -59,7 +59,7 @@ jobs: - run: echo 'export PATH=${HOME}/bin:${PATH}' >> ${BASH_ENV} - attach_workspace: at: . - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: make promu - run: make dep - run: promu crossbuild tarballs From 8abb0a6d1ffaeb7daaf2e23819f27b34cf1b0b53 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:35:32 -0700 Subject: [PATCH 128/182] keep trying dep fixes --- .circleci/config.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 40b4bcf..49fa37b 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -10,17 +10,19 @@ jobs: steps: - checkout - setup_remote_docker - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: make promu - run: make build: machine: true working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly + environment: + GOPATH: /home/circleci/.go_workspace steps: - checkout - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh + - run: mkdir /home/circleci/.go_workspace/bin + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: make promu - run: make dep - run: promu crossbuild -v @@ -39,7 +41,6 @@ jobs: - setup_remote_docker - attach_workspace: at: . - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: ln -s .build/linux-amd64/telly telly - run: make docker - run: docker images @@ -59,7 +60,6 @@ jobs: - run: echo 'export PATH=${HOME}/bin:${PATH}' >> ${BASH_ENV} - attach_workspace: at: . - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | INSTALL_DIRECTORY=/usr/local/bin sh - run: make promu - run: make dep - run: promu crossbuild tarballs From c8af25383fdc279a44e99886754bd0f32866696f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:37:15 -0700 Subject: [PATCH 129/182] fix test --- .circleci/config.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 49fa37b..dd95c65 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -41,6 +41,7 @@ jobs: - setup_remote_docker - attach_workspace: at: . + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: ln -s .build/linux-amd64/telly telly - run: make docker - run: docker images @@ -60,6 +61,7 @@ jobs: - run: echo 'export PATH=${HOME}/bin:${PATH}' >> ${BASH_ENV} - attach_workspace: at: . + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: make promu - run: make dep - run: promu crossbuild tarballs From d37dea35ba2d38d802af60ef594fcc4edaeb691b Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 20:40:00 -0700 Subject: [PATCH 130/182] fix test --- .circleci/config.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index dd95c65..7b9229c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -10,6 +10,7 @@ jobs: steps: - checkout - setup_remote_docker + - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - run: make promu - run: make From 6e9dc1520b48669359b65cbb208a1afedb624c0d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 21:36:42 -0700 Subject: [PATCH 131/182] Disable setting docker latest tag --- .circleci/config.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 7b9229c..0da2f31 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -74,11 +74,11 @@ jobs: - run: ln -s .build/linux-amd64/telly telly - run: make docker DOCKER_IMAGE_TAG=$CIRCLE_TAG - run: docker login -u $DOCKER_LOGIN -p $DOCKER_PASSWORD - - run: | - if [[ "$CIRCLE_TAG" =~ ^v[0-9]+(\.[0-9]+){2}$ ]]; then - make docker-tag-latest DOCKER_IMAGE_TAG="$CIRCLE_TAG" + # - run: | + # if [[ "$CIRCLE_TAG" =~ ^v[0-9]+(\.[0-9]+){2}$ ]]; then + # make docker-tag-latest DOCKER_IMAGE_TAG="$CIRCLE_TAG" - fi + # fi - run: make docker-publish workflows: From 10ed01d395b0cba92a894ec60d1684e8524748e9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 22:22:42 -0700 Subject: [PATCH 132/182] set DOCKER_REPO --- Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/Makefile b/Makefile index b15f8e4..36d2032 100644 --- a/Makefile +++ b/Makefile @@ -11,6 +11,7 @@ PREFIX ?= $(shell pwd) BIN_DIR ?= $(shell pwd) DOCKER_IMAGE_NAME ?= telly DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD)) +DOCKER_REPO ?= tellytv all: dep style build test From fa271a9c58ce7726592555b1e22afb47c5c2670e Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 23:09:24 -0700 Subject: [PATCH 133/182] Merge Dockerfiles together so ffmpeg is always included, ensure make/gcc etc is installed --- Dockerfile | 8 ++++---- Dockerfile.ffmpeg | 4 ---- 2 files changed, 4 insertions(+), 8 deletions(-) delete mode 100644 Dockerfile.ffmpeg diff --git a/Dockerfile b/Dockerfile index fb5a489..9ceac30 100644 --- a/Dockerfile +++ b/Dockerfile @@ -5,21 +5,21 @@ ADD https://github.com/golang/dep/releases/download/v0.5.0/dep-linux-amd64 /usr/ RUN chmod +x /usr/bin/dep # Install git because gin/yaml needs it -RUN apk update && apk upgrade && apk add git +RUN apk update && apk upgrade && apk add --update git gcc g++ musl-dev # Copy the code from the host and compile it WORKDIR $GOPATH/src/github.com/tellytv/telly COPY Gopkg.toml Gopkg.lock ./ RUN dep ensure --vendor-only COPY . ./ -RUN CGO_ENABLED=0 GOOS=linux go build -a -installsuffix nocgo -o /app . +RUN CGO_ENABLED=1 GOOS=linux go build -a -installsuffix nocgo -o /app . # install ca root certificates + listen on 0.0.0.0 + build RUN apk add --no-cache ca-certificates \ && find . -type f -print0 | xargs -0 sed -i 's/"listen", "localhost/"listen", "0.0.0.0/g' \ - && CGO_ENABLED=0 GOOS=linux go install -ldflags '-w -s -extldflags "-static"' + && CGO_ENABLED=1 GOOS=linux go install -ldflags '-w -s -extldflags "-static"' -FROM scratch +FROM jrottenberg/ffmpeg:4.0-alpine COPY --from=builder /app ./ COPY --from=builder /etc/ssl/certs/ /etc/ssl/certs/ EXPOSE 6077 diff --git a/Dockerfile.ffmpeg b/Dockerfile.ffmpeg deleted file mode 100644 index ec62afe..0000000 --- a/Dockerfile.ffmpeg +++ /dev/null @@ -1,4 +0,0 @@ -FROM jrottenberg/ffmpeg:4.0-alpine -COPY --from=tellytv/telly:dev /app /app -EXPOSE 6077 -ENTRYPOINT ["/app"] From 076c9c2dcffdfb4692394a763634cd518eacb755 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 23:09:36 -0700 Subject: [PATCH 134/182] Fix make docker --- Makefile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 36d2032..8a1e915 100644 --- a/Makefile +++ b/Makefile @@ -47,7 +47,7 @@ tarball: promu docker: @echo ">> building docker image" - @docker build -t "$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . + @docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . docker-publish: @echo ">> publishing docker image" From 454a1b1ea4af618ac54648b3ee9d5f4bb503f8d3 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 23:37:04 -0700 Subject: [PATCH 135/182] Fix .promu.yml to build sqlite3 with proper tags and cgo enabled --- .promu.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.promu.yml b/.promu.yml index eeb4831..0684714 100644 --- a/.promu.yml +++ b/.promu.yml @@ -1,7 +1,10 @@ repository: path: github.com/tellytv/telly +go: + version: 1.11 + cgo: true build: - flags: -a -tags netgo + flags: -a -tags 'netgo json1' ldflags: | -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} From 0cfd3b2e01de05da7b86a3975d8ce14de89f5d0b Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 5 Sep 2018 23:38:40 -0700 Subject: [PATCH 136/182] change go version --- .promu.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.promu.yml b/.promu.yml index 0684714..6e6068c 100644 --- a/.promu.yml +++ b/.promu.yml @@ -1,7 +1,7 @@ repository: path: github.com/tellytv/telly go: - version: 1.11 + version: 1.10.3 cgo: true build: flags: -a -tags 'netgo json1' From 28fbdcb50e6eed92e79d6bbefa73e5fcae21b9ed Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 00:00:20 -0700 Subject: [PATCH 137/182] work on promu crossbuild --- .promu.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.promu.yml b/.promu.yml index 6e6068c..30ebb04 100644 --- a/.promu.yml +++ b/.promu.yml @@ -1,11 +1,11 @@ repository: path: github.com/tellytv/telly go: - version: 1.10.3 cgo: true build: flags: -a -tags 'netgo json1' ldflags: | + -linkmode=external -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} From 5fcdea8785f4d39249d0a363275e3df126d8ad37 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 00:00:35 -0700 Subject: [PATCH 138/182] more work on makefile --- Makefile | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-) diff --git a/Makefile b/Makefile index 8a1e915..77dc755 100644 --- a/Makefile +++ b/Makefile @@ -54,9 +54,7 @@ docker-publish: @docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" promu: - @GOOS=$(shell uname -s | tr A-Z a-z) \ - GOARCH=$(subst x86_64,amd64,$(patsubst i%86,386,$(shell uname -m))) \ - $(GO) get -u github.com/prometheus/promu + $(GO) get -u github.com/prometheus/promu .PHONY: all style dep format build test vet tarball docker docker-publish promu From e945a1fe1727e290f8ecdb29989e4f62c45b4916 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 00:44:52 -0700 Subject: [PATCH 139/182] remove freebsd from promu builds --- .promu.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.promu.yml b/.promu.yml index 30ebb04..151fdb7 100644 --- a/.promu.yml +++ b/.promu.yml @@ -23,7 +23,5 @@ crossbuild: - darwin/386 - windows/amd64 - windows/386 - - freebsd/amd64 - - freebsd/386 - linux/arm - linux/arm64 From 110d00f4ce86ca36f33d140472a3d15488f7cb84 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 01:07:48 -0700 Subject: [PATCH 140/182] more makefile fixes --- Makefile | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/Makefile b/Makefile index 77dc755..9d80553 100644 --- a/Makefile +++ b/Makefile @@ -1,10 +1,12 @@ -# Need CGO_ENABLED=1 for go-sqlite3 -GO ?= CGO_ENABLED=1 go +# Ensure GOBIN is not set during build so that promu is installed to the correct path +unexport GOBIN + +GO ?= go GOFMT ?= $(GO)fmt FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH))) PROMU := $(FIRST_GOPATH)/bin/promu -GOMETALINTER_BINARY := CGO_ENABLED=1 $(FIRST_GOPATH)/bin/gometalinter +GOMETALINTER_BINARY := $(FIRST_GOPATH)/bin/gometalinter DEP_BINARY := $(FIRST_GOPATH)/bin/dep PREFIX ?= $(shell pwd) @@ -54,7 +56,7 @@ docker-publish: @docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" promu: - $(GO) get -u github.com/prometheus/promu + GOOS= GOARCH= $(GO) get -u github.com/prometheus/promu .PHONY: all style dep format build test vet tarball docker docker-publish promu From 32d106c6ad5690aa1a71de5cb4a43d337672d51c Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 15:42:34 -0700 Subject: [PATCH 141/182] Fix Squirrel issues and startup with 0 channels --- internal/commands/guide_updates.go | 4 +++ internal/guideproviders/schedules_direct.go | 2 +- internal/models/guide_source.go | 2 +- internal/models/guide_source_channel.go | 4 +-- internal/models/guide_source_programme.go | 10 +++---- internal/models/lineup.go | 2 +- internal/models/lineup_channel.go | 29 ++++++++++++--------- internal/models/video_source.go | 2 +- internal/models/video_source_track.go | 4 +-- 9 files changed, 33 insertions(+), 26 deletions(-) diff --git a/internal/commands/guide_updates.go b/internal/commands/guide_updates.go index d4b070d..2a5d744 100644 --- a/internal/commands/guide_updates.go +++ b/internal/commands/guide_updates.go @@ -60,6 +60,10 @@ func fireGuideUpdates(cc *context.CContext, provider *models.GuideSource) error return fmt.Errorf("error getting guide sources for lineup: %s", guideChannelsErr) } + if len(guideChannels) == 0 { + return nil + } + channelsToGet := make(map[string]guideproviders.Channel) for _, channel := range guideChannels { diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 3658678..7998be2 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -215,7 +215,7 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input // Next, we get all modified parts of the schedule for any channels. lastModifieds, lastModifiedsErr := s.client.GetLastModified(reqs) if lastModifiedsErr != nil { - return nil, nil, fmt.Errorf("error getting lastModifieds from lastModifieds direct: %s", lastModifiedsErr) + return nil, nil, fmt.Errorf("error getting lastModifieds from schedules direct: %s", lastModifiedsErr) } channelsNeedingUpdate := make(map[string][]string) diff --git a/internal/models/guide_source.go b/internal/models/guide_source.go index 99d4282..1133d18 100644 --- a/internal/models/guide_source.go +++ b/internal/models/guide_source.go @@ -112,7 +112,7 @@ func (db *GuideSourceDB) GetGuideSourceByID(id int) (*GuideSource, error) { if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Get(&guideSource, sql, args) + err := db.SQL.Get(&guideSource, sql, args...) return &guideSource, err } diff --git a/internal/models/guide_source_channel.go b/internal/models/guide_source_channel.go index 564125e..5d090f7 100644 --- a/internal/models/guide_source_channel.go +++ b/internal/models/guide_source_channel.go @@ -112,7 +112,7 @@ func (db *GuideSourceChannelDB) GetGuideSourceChannelByID(id int, expanded bool) if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Get(&channel, sql, args) + err := db.SQL.Get(&channel, sql, args...) if err != nil { return nil, err } @@ -146,6 +146,6 @@ func (db *GuideSourceChannelDB) GetChannelsForGuideSource(guideSourceID int) ([] if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Select(&channels, sql, args) + err := db.SQL.Select(&channels, sql, args...) return channels, err } diff --git a/internal/models/guide_source_programme.go b/internal/models/guide_source_programme.go index 9730116..223791e 100644 --- a/internal/models/guide_source_programme.go +++ b/internal/models/guide_source_programme.go @@ -120,7 +120,7 @@ func (db *GuideSourceProgrammeDB) GetGuideSourceProgrammeByID(id int) (*GuideSou if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Get(&programme, sql, args) + err := db.SQL.Get(&programme, sql, args...) if err != nil { return nil, err } @@ -142,11 +142,11 @@ func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID string, // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("WHERE G.channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) ORDER BY start ASC").ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) ORDER BY start ASC").ToSql() if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Select(&programmes, sql, args) + err := db.SQL.Select(&programmes, sql, args...) if err != nil { return nil, err } @@ -166,7 +166,7 @@ func (db *GuideSourceProgrammeDB) GetProgrammesForChannel(channelID string) ([]G if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Select(&programmes, sql, args) + err := db.SQL.Select(&programmes, sql, args...) if err != nil { return nil, err } @@ -186,7 +186,7 @@ func (db *GuideSourceProgrammeDB) GetProgrammesForGuideID(guideSourceID int) ([] if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Select(&programmes, sql, args) + err := db.SQL.Select(&programmes, sql, args...) if err != nil { return nil, err } diff --git a/internal/models/lineup.go b/internal/models/lineup.go index 227ed8d..d969b52 100644 --- a/internal/models/lineup.go +++ b/internal/models/lineup.go @@ -206,7 +206,7 @@ func (db *LineupDB) GetLineupByID(id int, withChannels bool) (*Lineup, error) { if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Get(&lineup, sql, args) + err := db.SQL.Get(&lineup, sql, args...) if withChannels { channels, channelsErr := db.Collection.LineupChannel.GetChannelsForLineup(lineup.ID, true) if channelsErr != nil { diff --git a/internal/models/lineup_channel.go b/internal/models/lineup_channel.go index bc20e27..1a76898 100644 --- a/internal/models/lineup_channel.go +++ b/internal/models/lineup_channel.go @@ -166,7 +166,7 @@ func (db *LineupChannelDB) GetLineupChannelByID(lineupID int, channelNumber stri return nil, sqlGenErr } - err := db.SQL.Get(&channel, sql, args) + err := db.SQL.Get(&channel, sql, args...) if err != nil { return nil, err } @@ -200,7 +200,7 @@ func (db *LineupChannelDB) GetChannelsForLineup(lineupID int, expanded bool) ([] if sqlGenErr != nil { return nil, sqlGenErr } - err := db.SQL.Select(&channels, sql, args) + err := db.SQL.Select(&channels, sql, args...) if err != nil { return nil, err } @@ -231,19 +231,22 @@ func (db *LineupChannelDB) GetEnabledChannelsForGuideProvider(providerID int) ([ return nil, sqlGenErr } - err := db.SQL.Select(&channels, sql, args) + err := db.SQL.Select(&channels, sql, args...) if err != nil { return nil, err } - // Need to get the address and port number to properly fill - lineup, lineupErr := db.Collection.Lineup.GetLineupByID(channels[0].LineupID, false) - if lineupErr != nil { - return nil, lineupErr - } - for idx, channel := range channels { - channel.lineup = lineup - channel.Fill(db.Collection) - channels[idx] = channel + + if len(channels) > 0 { + // Need to get the address and port number to properly fill + lineup, lineupErr := db.Collection.Lineup.GetLineupByID(channels[0].LineupID, false) + if lineupErr != nil { + return nil, lineupErr + } + for idx, channel := range channels { + channel.lineup = lineup + channel.Fill(db.Collection) + channels[idx] = channel + } } return channels, err } @@ -260,7 +263,7 @@ func (db *LineupChannelDB) GetEnabledChannelsForVideoProvider(providerID int) ([ return nil, sqlGenErr } - err := db.SQL.Select(&channels, sql, args) + err := db.SQL.Select(&channels, sql, args...) if err != nil { return nil, err } diff --git a/internal/models/video_source.go b/internal/models/video_source.go index cc34fd1..90f3a34 100644 --- a/internal/models/video_source.go +++ b/internal/models/video_source.go @@ -106,7 +106,7 @@ func (db *VideoSourceDB) GetVideoSourceByID(id int) (*VideoSource, error) { return nil, sqlGenErr } - err := db.SQL.Get(&videoSource, sql, args) + err := db.SQL.Get(&videoSource, sql, args...) return &videoSource, err } diff --git a/internal/models/video_source_track.go b/internal/models/video_source_track.go index f497250..2e838de 100644 --- a/internal/models/video_source_track.go +++ b/internal/models/video_source_track.go @@ -93,7 +93,7 @@ func (db *VideoSourceTrackDB) GetVideoSourceTrackByID(id int, expanded bool) (*V return nil, sqlGenErr } - err := db.SQL.Get(&track, sql, args) + err := db.SQL.Get(&track, sql, args...) if expanded { video, videoErr := db.Collection.VideoSource.GetVideoSourceByID(track.VideoSourceID) if videoErr != nil { @@ -127,6 +127,6 @@ func (db *VideoSourceTrackDB) GetTracksForVideoSource(videoSourceID int) ([]Vide return nil, sqlGenErr } - err := db.SQL.Select(&tracks, sql, args) + err := db.SQL.Select(&tracks, sql, args...) return tracks, err } From 4fc5e7f608a33982fee215377f076bd53f899e97 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:27:14 -0700 Subject: [PATCH 142/182] Simplify Dockerfile, improve .promu.yml, make default listen address 0.0.0.0 --- .promu.yml | 7 +++++-- Dockerfile | 28 +++++----------------------- main.go | 8 +++++++- 3 files changed, 17 insertions(+), 26 deletions(-) diff --git a/.promu.yml b/.promu.yml index 151fdb7..bfe7e6a 100644 --- a/.promu.yml +++ b/.promu.yml @@ -3,9 +3,12 @@ repository: go: cgo: true build: - flags: -a -tags 'netgo json1' + flags: -a -tags 'netgo cgo static_build json1' ldflags: | - -linkmode=external + -linkmode external + -w + -extldflags + -static -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} diff --git a/Dockerfile b/Dockerfile index 9ceac30..c36a2cc 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,26 +1,8 @@ -FROM golang:alpine as builder - -# Download and install the latest release of dep -ADD https://github.com/golang/dep/releases/download/v0.5.0/dep-linux-amd64 /usr/bin/dep -RUN chmod +x /usr/bin/dep - -# Install git because gin/yaml needs it -RUN apk update && apk upgrade && apk add --update git gcc g++ musl-dev +FROM jrottenberg/ffmpeg:4.0-alpine -# Copy the code from the host and compile it -WORKDIR $GOPATH/src/github.com/tellytv/telly -COPY Gopkg.toml Gopkg.lock ./ -RUN dep ensure --vendor-only -COPY . ./ -RUN CGO_ENABLED=1 GOOS=linux go build -a -installsuffix nocgo -o /app . +RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev -# install ca root certificates + listen on 0.0.0.0 + build -RUN apk add --no-cache ca-certificates \ - && find . -type f -print0 | xargs -0 sed -i 's/"listen", "localhost/"listen", "0.0.0.0/g' \ - && CGO_ENABLED=1 GOOS=linux go install -ldflags '-w -s -extldflags "-static"' +COPY telly /bin/telly -FROM jrottenberg/ffmpeg:4.0-alpine -COPY --from=builder /app ./ -COPY --from=builder /etc/ssl/certs/ /etc/ssl/certs/ -EXPOSE 6077 -ENTRYPOINT ["./app"] +EXPOSE 6077 +ENTRYPOINT ["/bin/telly"] diff --git a/main.go b/main.go index 1834268..08a8740 100644 --- a/main.go +++ b/main.go @@ -34,7 +34,7 @@ var ( func main() { // Web flags - flag.StringP("web.listen-address", "l", "localhost:6077", "Address to listen on for web interface, API and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") + flag.StringP("web.listen-address", "l", ":6077", "Address to listen on for web interface, API and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") // Log flags flag.String("log.level", logrus.InfoLevel.String(), "Only log messages with the given severity or above. Valid levels: [debug, info, warn, error, fatal] $(TELLY_LOG_LEVEL)") @@ -117,6 +117,9 @@ func main() { } for _, videoSource := range videoProviders { + if videoSource.UpdateFrequency == "" { + continue + } commands.StartFireVideoUpdates(cc, videoSource) if addErr := c.AddFunc(videoSource.UpdateFrequency, func() { commands.StartFireVideoUpdates(cc, videoSource) }); addErr != nil { log.WithError(addErr).Errorln("error when adding video source to scheduled background jobs") @@ -124,6 +127,9 @@ func main() { } for _, guideSource := range guideProviders { + if guideSource.UpdateFrequency == "" { + continue + } commands.StartFireGuideUpdates(cc, guideSource) if addErr := c.AddFunc(guideSource.UpdateFrequency, func() { commands.StartFireGuideUpdates(cc, guideSource) }); addErr != nil { log.WithError(addErr).Errorln("error when adding guide source to scheduled background jobs") From 34333423dc12ac5fb515748dc052023827da7ded Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:27:34 -0700 Subject: [PATCH 143/182] Add docker-tag-latest to Makefile --- Makefile | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Makefile b/Makefile index 9d80553..97d7aaa 100644 --- a/Makefile +++ b/Makefile @@ -55,11 +55,14 @@ docker-publish: @echo ">> publishing docker image" @docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" +docker-tag-latest: + @docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):latest" + promu: GOOS= GOARCH= $(GO) get -u github.com/prometheus/promu -.PHONY: all style dep format build test vet tarball docker docker-publish promu +.PHONY: all style dep format build test vet tarball docker docker-publish docker-tag-latest promu run: From e78b7cad78f52662393025881b62e61cec899860 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:27:50 -0700 Subject: [PATCH 144/182] Properly expose the Prometheus version collector to Prometheus --- internal/metrics/metrics.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/metrics/metrics.go b/internal/metrics/metrics.go index 1619563..a130f4b 100644 --- a/internal/metrics/metrics.go +++ b/internal/metrics/metrics.go @@ -63,7 +63,7 @@ var ( // nolint func init() { - version.NewCollector("telly") + prometheus.MustRegister(version.NewCollector("telly")) prometheus.MustRegister(ExposedChannels) prometheus.MustRegister(ActiveStreams) prometheus.MustRegister(PausedStreams) From 7258eb53f64af38f14a5b2017c02ac554f220ce9 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:28:06 -0700 Subject: [PATCH 145/182] Set default update frequency of the guide & video providers to daily --- migrations/20180905174455-initial.sql | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/migrations/20180905174455-initial.sql b/migrations/20180905174455-initial.sql index c1913d2..42dc99e 100644 --- a/migrations/20180905174455-initial.sql +++ b/migrations/20180905174455-initial.sql @@ -10,7 +10,7 @@ CREATE TABLE IF NOT EXISTS video_source ( base_url TEXT, m3u_url TEXT, max_streams INTEGER, - update_frequency TEXT, + update_frequency TEXT DEFAULT '@daily', imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); @@ -36,7 +36,7 @@ CREATE TABLE IF NOT EXISTS guide_source ( password VARCHAR(64) NULL, xmltv_url TEXT, provider_data TEXT, - update_frequency TEXT, + update_frequency TEXT DEFAULT '@daily', imported_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ); From 9bb2ca5b3b6ab12e471c38a7d4ed615215b2f0e1 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:29:34 -0700 Subject: [PATCH 146/182] Update frontend --- frontend | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frontend b/frontend index 221b5b3..23d8d0a 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 221b5b3a4fd869b3e14242d0d5f9ed584aa8dc84 +Subproject commit 23d8d0a7cc44611486a2a8d47e115acf88f8f2cf From f57cc1b2515e512fa520fd9a274d40a61aa7eddc Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:29:43 -0700 Subject: [PATCH 147/182] update packr data --- internal/api/a_api-packr.go | 18 +++++++++--------- internal/context/a_context-packr.go | 4 ++-- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/internal/api/a_api-packr.go b/internal/api/a_api-packr.go index b78e6bf..b3573eb 100644 --- a/internal/api/a_api-packr.go +++ b/internal/api/a_api-packr.go @@ -7,13 +7,13 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"H4sIAAAAAAAA/9SbD3BcRR3HP2dqKwImU/+LmKhFK1EbxhKjA3NYUTrVUVsHi2UY0CjWP1XHaU2HQS6VgYB/iAaltVMt0iowY/0/SrHawxBaKJZMxWrRQmIGQVSS0H+JvWSdzX1f3a737i53996L35mdvbdv9/2+u2/f7u/3299BijpaWmzexB1nQSvQ1KTrBnj0LGhoyF+vnAXXt8J8oAW4gnz5FOZRCingQuB9MzQtBmaFcG8GegEzw9N+jbGL1wLHZgC3ctM4cJ4zZ35bou59wCbgZuBGoBPoAFYBHwEuBZYCS5SvANp1//NARu169Jx7gX9X2Ye/Ay/QvCp0/2HgIuCUkl9NZXiu+vpYFX2wY/fZAuUbgdkR8fZxGnBXhfxXFuC/N0buARqBozXi/4GYuQdYVwP+9pt6XkL8z60B/98nxB2tExNV8u9LkL/FAY/fpNbaO4DfAIdL8P9lwvx/5HDJAZd799uAZ4rwvzMh3gFud7h8O6TOJ4vw3xQzXx/fd7isCalzfhH+N8XM18f3HC5fCKmzuAj/dTHz9bHV4bJDupmP73r8P+Ncr06As4ut3vryLeDFwIuANwJfL7D+rCrjncWFLRWs/+73/LWE+d/m8fu1zMi5wCuBq7w9zvL/uHN9W8L83bm9Wzq2j+0e/4851z9PgLOLWx0u14TUWenx/6hzvStmvj7c+f+5kDqLPP7tzvWBmPn6eMDhsj6kzhqP/4ec63/EzNdFnWfD5GRXu2gGnvT4X+61mZMQ/7MLrI85+Q7ulG58pMD6eZlXdnFC/D88zbU/4H+pV7YjAe7W5huqkP8HC5THvQ9vqIB7wD8dcs/q4q+OmPc7S/jOSiW7dz0beCrkvv1+HgJu0T7dru/dzrnlwPvl/3q39NoLgQvk27O20kLgHOBtwCXSFa+XbbK3Ct5Ga9WrNA52Tzhe5fPiTiu8d3kFMDoDeJVKx4C1IfNxrmyYLbL5fwD8BPgFcDewUz723dorH9Q86Af2yf/yB/lWfbn/ku/7YdXtV9sH9azd8jVYGb+STCt7m7hslQ/4ZRF/k3h7fJCStk3LxZuAkZD3flHS5ErA2hpPO5x/5tmEx7RmzkQ0S/8LuH4HeJbufdHrg3/+kzTsN/VXh+NGh3uA67y1++0JcfVxmva4gNuNRer6fVgUI89CmCWfacCpo4w21zj1j2i/TgprxWMCuHIa7TqcPhx2zhLjxuu071RyZuP6/Z4B3hwBv6jxCfn4bR+GtXf8v6Hd8UlZHWNB0oQqwGXS1Y10+eakCVWA5Y4O/wTwwqQJVYClOgO1a9IrkiZTIc5x7KqSMFOAAfKenyx5T1JnncmSgnX2bgquNcZ0pqDLGJNNQbeTD4Tkg6PKx/P5kJfb+5tt/UHlQfvRk9v/T7vxk++7cgN+XeIb8O9MmxGbB/0L+msVZertOOQa7TgYM6Z8pD6fD3bl897efN41mM8bx/J5OpeZyjOTaZMfz0bl3cp3KR9Sfsj8d9znw1R01gVunFZD0VdmdfgbYkrLPNk3J2CvBmeyi73ycfnyr5IfZzpprezLcmOIrpQ+H1wfqNEabfeqgTLkr/fOBpbWQHaAd5Uhf4Mjf3/IuWI18OMOisn/Uo1lozlWrvyrI5B/tSNrtewxq0/+uYD8VRHID3TZ7V75ogLy/ZiKWsr3zw+bHfmbI5j7vvzHgTc45T2O/OD7f0+E8gN76C7Pv7pBsR1Gfsao5Od0jnG67PsHHPkb9TvsXK8W8rd55csc+YGP/7oI5Af26O1e+UJH/i3OWlxr3OrYL2c75d905H9Dv7MRyP+dN//2AIPe/OtxrpfUUHZLGb5/K7/b23/PrIHsMz3fUTH5/jndpM5urA39Dp2RnO+cm9h+vZ68ijdPZ0l2TX+vzm02T0P/WC1/3I+r0KMqTTucmPvZwKc0B/uA+zV39kkv+BPwiPatg8CjwCHnWUdUdlB1HlGb/XrGXq059tn3qN/VxF+nFMMSyN9T5P8DUWC95B5UP43OMupikP0VydsnW7xevi4jn7rv360lgpgyK+/5Tnm9YlSMYnWi4LBM/qC7gVML3D/d+Z/Ipgh02TWKIywWw36q4mmj2k/KwSlOLFRPQhzmKObKaL4mgdlO3LAfLxMX7Jr0aeA5YRUGYE4npK41I6l6k6PRTJ5IaWPa0sacp2R/nyhrnEqTbUFd29Y+wz7LPtPk0nmXx2i3MYd2GfPEkDHDo8aYMWNMLmPMZMYYY+bLLdHk+ikKr6TzNJ5ZreH3aJ/sVbpXqU+xPfdpTfgp8BLpvnaf+LL2ywUFUivwVfkA3L0qq3PlG8oc921e+36lcs+FLlG7Lepb0P7cMtu3aV+wOENtH5qGb6FNOkSH1pF+7cet02j/T9mbK9R+j/SZcnAx8DetJUvU/v5pxEH/UOP3NDCm9tudGAU77V4OvFR72FxNweWKBfbff5/Gcadsuad0rjGiNKEUXA+rzuOao8V8vq+RX/vJCnw/Z0jHsTriW4G/6OypXNzkzam3AH/U/wYrxULFa5T+V2g4Fvhx/p0paMxCegAyI5A5CpnDyo/my9PZfL3JDEzshOOPgRkGY+A/AQAA//88VL/W7joAAA==\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") } diff --git a/internal/context/a_context-packr.go b/internal/context/a_context-packr.go index 1ee89ea..a0264ad 100644 --- a/internal/context/a_context-packr.go +++ b/internal/context/a_context-packr.go @@ -7,6 +7,6 @@ import "github.com/gobuffalo/packr" // You can use the "packr clean" command to clean up this, // and any other packr generated files. func init() { - packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXW2/iOBR+z6/wW0ELVUtvM5qnlJhptDR0g7PqPEWexAVrEzvjCy3/fkVCgh2SLlvtRRoec75z+77jY+OMx+CXnK4EVgREheNMQ+giCJB7P4fAn4FggQB89pdoCTY0JTyWXIuEgIEDAE2B/fMDBL/CEDyF/qMbfgO/wm/AjdDCD6YhfIQBGjkAMJwTywvB59JQCL5LIRrD7244fXDDwe31EATRfL4DaUmEFaELVGApX7lI3wV9x5LEWmRHdeRX2vp+MOC3WCpBcC6tfsu6ihQrEr8I8kMTlmwbJ5oXXCiSxljto/mPcIncxyfgwZkbzRGYRmEIAxQ3Fmf45WQlYiVw8kenHifJYcWiqdlTW6m6pYqDuElnuGR8xbtc1LboDJVgRVZcbNvfSbGKzXb62DyBzJHjADBbhND/GuwoGLQ6HoIQzmAIgym0mR3QdPhXSqw0TcnPcybe8kxtzOFv1xGnWGHT8J/Ovcl2nKwxYyT7+ORX0Q6uxhhXPBxMfTTU32tW/qlxnS6CJQpdP0Bg32asGf2hCYgC/7cIgkFd/KipdThqzXkNsQbcpPDvDnhcCL4SOM+rUe/grzzSe12OtwYWyuTo0DEAhNkKWsbdhJlGz0Xwf1KjYaBfj33/o6rh0a61f0eajDKii+6t8+HFYwom06Jtu18s5tANGsJQGJVSZFQqwmKcpoJIeYjTAM8uJ3fnF+cX55dnpURUJnxDxNZweQ+/E66nwfJ60YwI2WvOMdMvOFFaHDapnW1JM5pwlmqpynw5T0kW2+zYHg/eA89JqBmAzwgGnumm8+99iR48NB1PomUJf6Eif8WCmIls+Dpd85wIzVQSYyUT221DhKScHbtNLi5vLj5NbiuuyYYmxLpOj7i+ur65vftkwrFW6x64Ilm2NbFaG8G7Q49dOHHH1/Dmenx/P/08vrpyZ3fejXfrfp6cGY8KJTCTtdotLpQqSmgiCDZvlhPP8mnn6d175bRDtQ/UebMoqrLul9B+zzfDUxuqJ0n5yqtCGtGqlVG72q+3dbv2/dktJwhvuKDGVjVsR+x+5I3VUGBtuOrroOOuspvsfZJViK4AbSZ6N2uNaTas9RfI46/Mcbxw8bQfETP7lz5DVZZlNlP2GupaLEBFUsenA/rPAAAA//9uhhgAtg0AAA==\"") - packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") + packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXSW/jNhS+61fwFhu1g8TZZjCXKjY9EerIqUwVmZPAERmbqCRquDjjf19Ym0lZSt2gRYDqyPe97XsLKWc8Br+kbC2woiDMHWcaQBdBgNz7BQTeHPhLBOCzt0IrsGWE8khyLWIKBg4AjAD783wEv8IAPAXeoxt8A7/Bb8AN0dLzpwF8hD4aOQBkOKWWFoLPhSAXfO9CNII/3GD64AaD2+sh8MPFYg/SkgrLQhcox1K+ckHeBH3HkkZaJEdxpFfaOj8I8M9IKkFxKq18i7hyghWNXgT9oWkW7wolMINzN1wgcPYrwSzZne2RLM25UJREWFXmvUe4Qu7jUwOfhkEAfRQ1Emf45eTSRErg+M/OAp1UH8sWI2aS7dLVxJSkRI07QyXha96lonZ5p6kYK7rmYtc+p/k6MtOpz9tsnkDmyHEAmC8D6H319xQMWhkPQQDnMID+FNrMDhgZ/l0l1poR+v8Zkp9porbmNLTjiAhW2BR87CCY9EfxBmcZTd4/CqW1g6rR1yUxB1EfL/V5TdO/1b/Tpb9Cgev5CFRpRjpjPzQFoe/9HkIwqIMfNbEOR63GryFWx5sU/tOOj3LB1wKnadn7HfwVM17V5XiNYKFMjg4ZA0Azu4KWcN9ypnDmIvhB1WgY6K9Hlf+oTHi0T+2/KU3CMqrz7jX07k1kFkySvC27Xy4X0PUbwlAQFqVImFQ0izAhgkp5sHNYDZeTu/OL84vzy2I7ECZjvqViZ6i8hd8XrifB4r7RGRWyV5ziTL/gWGlxWK22txVLWMwzoqUq/KWc0CSy2bE1HmYPPKWBzgB8RtCfmWo6/d7n6GGGpuNJuCrgL0ykr1hQ05EN35ANT6nQmYojrGRsq22pkIxnx2qTi8ubi0+T25JrumUxte7XI66vrm9u7z6ZcKzVpgeuaFIt+QqrtWG82/TYhRN3fA1vrsf399PP46srd343u5ndup8nZ8YrQwmcybraLS6UygtoLCg2b5YTZ/m0eXrzXjltqCpDnTeLYirpfhpVe75pnlpQvlGKZ19p0rBWroxa1X7ObdqxV7NbdBDecsGMrWrIjth9z6OrocDacOXpoOOuspPsfaOViC4DbSZ6N2uNaTas9ZM046+Z48yC5VPVIqb3L32CMixLbLrsFdSxWICSpI6jA/qvAAAA//+mYnMb2A0AAA==\"") + packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") } From 7124cd7a6e6d7525403dad56fe787d5026063716 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:43:00 -0700 Subject: [PATCH 148/182] Try to pass around the logger instead of creating a new one in every package --- internal/api/guide_source.go | 10 +++++----- internal/api/main.go | 27 ++++++--------------------- internal/api/tuner.go | 6 +++++- internal/api/utils.go | 15 +++++++++------ internal/api/video_source.go | 8 ++++---- internal/commands/guide_updates.go | 2 +- internal/commands/video_updates.go | 2 +- internal/context/context.go | 24 +++++++++++++----------- internal/models/main.go | 18 ++++-------------- internal/streamsuite/stream.go | 10 +++++----- main.go | 2 +- 11 files changed, 54 insertions(+), 70 deletions(-) diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index 05be4aa..afc1a94 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -31,7 +31,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { cc.GuideSourceProviders[newGuide.ID] = provider - log.Infoln("Detected passed config is for provider", provider.Name()) + cc.Log.Infoln("Detected passed config is for provider", provider.Name()) lineupMetadata, reloadErr := provider.Refresh(nil) if reloadErr != nil { @@ -46,7 +46,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { channels, channelsErr := provider.Channels() if channelsErr != nil { - log.WithError(channelsErr).Errorln("unable to get channels from provider") + cc.Log.WithError(channelsErr).Errorln("unable to get channels from provider") c.AbortWithError(http.StatusBadRequest, channelsErr) return } @@ -54,7 +54,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { for _, channel := range channels { newChannel, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(newGuide.ID, channel, nil) if newChannelErr != nil { - log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) + cc.Log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) c.AbortWithError(http.StatusInternalServerError, newChannelErr) return } @@ -153,7 +153,7 @@ func subscribeToLineup(guideSource *models.GuideSource, provider guideproviders. channels, channelsErr := provider.Channels() if channelsErr != nil { - log.WithError(channelsErr).Errorln("unable to get channels from provider") + cc.Log.WithError(channelsErr).Errorln("unable to get channels from provider") c.AbortWithError(http.StatusBadRequest, channelsErr) return } @@ -163,7 +163,7 @@ func subscribeToLineup(guideSource *models.GuideSource, provider guideproviders. if channel.Lineup == lineupID { _, newChannelErr := cc.API.GuideSourceChannel.InsertGuideSourceChannel(guideSource.ID, channel, nil) if newChannelErr != nil { - log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) + cc.Log.WithError(newChannelErr).Errorf("Error creating new guide source channel %s!", channel.ID) c.AbortWithError(http.StatusInternalServerError, newChannelErr) return } diff --git a/internal/api/main.go b/internal/api/main.go index cfcfe8c..5e63926 100644 --- a/internal/api/main.go +++ b/internal/api/main.go @@ -2,38 +2,23 @@ package api import ( "net/http" - "os" "github.com/gin-gonic/gin" "github.com/gobuffalo/packr" "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/internal/context" - ginprometheus "github.com/zsais/go-gin-prometheus" -) - -var ( - log = &logrus.Logger{ - Out: os.Stderr, - Formatter: &logrus.TextFormatter{ - FullTimestamp: true, - }, - Hooks: make(logrus.LevelHooks), - Level: logrus.DebugLevel, - } - - prom = ginprometheus.NewPrometheus("http") ) // ServeAPI starts up the telly frontend + REST API. func ServeAPI(cc *context.CContext) { - log.Debugln("creating webserver routes") + cc.Log.Debugln("creating webserver routes") if viper.GetString("log.level") != logrus.DebugLevel.String() { gin.SetMode(gin.ReleaseMode) } - router := newGin() + router := newGin(cc) box := packr.NewBox("../../frontend/dist/telly-fe") @@ -73,11 +58,11 @@ func ServeAPI(cc *context.CContext) { c.JSON(http.StatusOK, cc.Streams) }) - log.Infof("telly is live and on the air!") - log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) - log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) + cc.Log.Infof("telly is live and on the air!") + cc.Log.Infof("Broadcasting from http://%s/", viper.GetString("web.listen-address")) + cc.Log.Infof("EPG URL: http://%s/epg.xml", viper.GetString("web.listen-address")) if err := router.Run(viper.GetString("web.listen-address")); err != nil { - log.WithError(err).Panicln("Error starting up web server") + cc.Log.WithError(err).Panicln("Error starting up web server") } } diff --git a/internal/api/tuner.go b/internal/api/tuner.go index 0283909..4f0b6cf 100644 --- a/internal/api/tuner.go +++ b/internal/api/tuner.go @@ -13,14 +13,18 @@ import ( "github.com/gin-gonic/gin" "github.com/koron/go-ssdp" uuid "github.com/satori/go.uuid" + "github.com/sirupsen/logrus" ccontext "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/metrics" "github.com/tellytv/telly/internal/models" "github.com/tellytv/telly/internal/streamsuite" ) +var log = &logrus.Logger{} + // ServeLineup starts up a server dedicated to a single Lineup. func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { + log = cc.Log channels, channelsErr := cc.API.LineupChannel.GetChannelsForLineup(lineup.ID, true) if channelsErr != nil { log.WithError(channelsErr).Errorln("error getting channels in lineup") @@ -38,7 +42,7 @@ func ServeLineup(cc *ccontext.CContext, exit chan bool, lineup *models.Lineup) { log.Debugln("creating device xml") upnp := discoveryData.UPNP() - router := newGin() + router := newGin(cc) router.GET("/", deviceXML(upnp)) router.GET("/device.xml", deviceXML(upnp)) diff --git a/internal/api/utils.go b/internal/api/utils.go index d0f1c2d..7aa9035 100644 --- a/internal/api/utils.go +++ b/internal/api/utils.go @@ -1,6 +1,7 @@ package api import ( + "fmt" "net/http" "time" @@ -12,13 +13,13 @@ import ( "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/models" "github.com/tellytv/telly/internal/utils" + ginprometheus "github.com/zsais/go-gin-prometheus" ) func scanM3U(c *gin.Context) { rawPlaylist, m3uErr := utils.GetM3U(c.Query("m3u_url")) if m3uErr != nil { - log.WithError(m3uErr).Errorln("unable to get m3u file") - c.AbortWithError(http.StatusBadRequest, m3uErr) + c.AbortWithError(http.StatusBadRequest, fmt.Errorf("unable to get m3u file: %s", m3uErr)) return } @@ -47,7 +48,7 @@ type LineupStatus struct { Found int `json:",omitempty"` // Number of found channels } -func ginrus() gin.HandlerFunc { +func ginrus(cc *context.CContext) gin.HandlerFunc { return func(c *gin.Context) { start := time.Now() // some evil middlewares modify this values @@ -68,7 +69,7 @@ func ginrus() gin.HandlerFunc { "time": end.Format(time.RFC3339), } - entry := log.WithFields(logFields) + entry := cc.Log.WithFields(logFields) if len(c.Errors) > 0 { // Append error field if this is an erroneous request. @@ -100,13 +101,15 @@ func ServeBox(urlPrefix string, box packr.Box) gin.HandlerFunc { } } -func newGin() *gin.Engine { +var prom = ginprometheus.NewPrometheus("http") + +func newGin(cc *context.CContext) *gin.Engine { router := gin.New() router.Use(cors.Default()) router.Use(gin.Recovery()) if viper.GetBool("log.requests") { - router.Use(ginrus()) + router.Use(ginrus(cc)) } prom.Use(router) diff --git a/internal/api/video_source.go b/internal/api/video_source.go index 4ae3274..8e0755f 100644 --- a/internal/api/video_source.go +++ b/internal/api/video_source.go @@ -11,7 +11,7 @@ import ( func getVideoSources(cc *context.CContext, c *gin.Context) { sources, sourcesErr := cc.API.VideoSource.GetAllVideoSources(false) if sourcesErr != nil { - log.WithError(sourcesErr).Errorln("error getting all video sources") + cc.Log.WithError(sourcesErr).Errorln("error getting all video sources") c.AbortWithError(http.StatusInternalServerError, sourcesErr) return } @@ -31,14 +31,14 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { provider, providerErr := providerCfg.GetProvider() if providerErr != nil { - log.WithError(providerErr).Errorln("error getting provider") + cc.Log.WithError(providerErr).Errorln("error getting provider") c.AbortWithError(http.StatusInternalServerError, providerErr) return } cc.VideoSourceProviders[newProvider.ID] = provider - log.Infoln("Detected passed config is for provider", provider.Name()) + cc.Log.Infoln("Detected passed config is for provider", provider.Name()) channels, channelsErr := provider.Channels() if channelsErr != nil { @@ -57,7 +57,7 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { EPGID: channel.EPGID, }) if newTrackErr != nil { - log.WithError(newTrackErr).Errorln("Error creating new video source track!") + cc.Log.WithError(newTrackErr).Errorln("Error creating new video source track!") c.AbortWithError(http.StatusInternalServerError, newTrackErr) return } diff --git a/internal/commands/guide_updates.go b/internal/commands/guide_updates.go index 2a5d744..a0424fc 100644 --- a/internal/commands/guide_updates.go +++ b/internal/commands/guide_updates.go @@ -25,7 +25,7 @@ var ( // FireGuideUpdatesCommand Command to fire one off guide source updates func FireGuideUpdatesCommand() { - cc, err := context.NewCContext() + cc, err := context.NewCContext(log) if err != nil { log.Fatalln("Couldn't create context", err) } diff --git a/internal/commands/video_updates.go b/internal/commands/video_updates.go index ec6e6ec..d9d392f 100644 --- a/internal/commands/video_updates.go +++ b/internal/commands/video_updates.go @@ -9,7 +9,7 @@ import ( // FireVideoUpdatesCommand Command to fire one off video source updates func FireVideoUpdatesCommand() { - cc, err := context.NewCContext() + cc, err := context.NewCContext(nil) if err != nil { panic(fmt.Errorf("couldn't create context: %s", err)) } diff --git a/internal/context/context.go b/internal/context/context.go index 564e521..042679c 100644 --- a/internal/context/context.go +++ b/internal/context/context.go @@ -45,19 +45,21 @@ func (cc *CContext) Copy() *CContext { } // NewCContext returns an initialized CContext struct -func NewCContext() (*CContext, error) { +func NewCContext(log *logrus.Logger) (*CContext, error) { + + if log == nil { + log = &logrus.Logger{ + Out: os.Stderr, + Formatter: &logrus.TextFormatter{ + FullTimestamp: true, + }, + Hooks: make(logrus.LevelHooks), + Level: logrus.DebugLevel, + } + } theCtx := ctx.Background() - log := &logrus.Logger{ - Out: os.Stderr, - Formatter: &logrus.TextFormatter{ - FullTimestamp: true, - }, - Hooks: make(logrus.LevelHooks), - Level: logrus.InfoLevel, - } - sql, dbErr := sqlx.Open("sqlite3", viper.GetString("database.file")) if dbErr != nil { log.WithError(dbErr).Panicln("Unable to open database") @@ -81,7 +83,7 @@ func NewCContext() (*CContext, error) { } log.Debugf("successfully applied %d migrations to database", numMigrations) - api := models.NewAPICollection(sql) + api := models.NewAPICollection(sql, log) tuners := make(map[int]chan bool) diff --git a/internal/models/main.go b/internal/models/main.go index f6ffefa..0363a79 100644 --- a/internal/models/main.go +++ b/internal/models/main.go @@ -1,24 +1,11 @@ package models import ( - "os" - "github.com/jmoiron/sqlx" "github.com/sirupsen/logrus" "gopkg.in/Masterminds/squirrel.v1" ) -var ( - log = &logrus.Logger{ - Out: os.Stderr, - Formatter: &logrus.TextFormatter{ - FullTimestamp: true, - }, - Hooks: make(logrus.LevelHooks), - Level: logrus.DebugLevel, - } -) - var sq = squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar) // nolint // APICollection is a struct containing all models. @@ -32,8 +19,11 @@ type APICollection struct { VideoSourceTrack VideoSourceTrackAPI } +var log = &logrus.Logger{} + // NewAPICollection returns an initialized APICollection struct. -func NewAPICollection(db *sqlx.DB) *APICollection { +func NewAPICollection(db *sqlx.DB, logger *logrus.Logger) *APICollection { + log = logger api := &APICollection{} api.GuideSource = newGuideSourceDB(db, api) diff --git a/internal/streamsuite/stream.go b/internal/streamsuite/stream.go index 47f5d5d..3894546 100644 --- a/internal/streamsuite/stream.go +++ b/internal/streamsuite/stream.go @@ -1,6 +1,7 @@ package streamsuite import ( + "fmt" "io" "net" "net/http" @@ -65,19 +66,18 @@ func (s *Stream) Start(c *gin.Context) { streamData, streamErr := s.Transport.Start(s.StreamURL) if streamErr != nil { - log.WithError(streamErr).Errorf("Error when starting streaming via %s", s.Transport.Type()) - c.AbortWithError(http.StatusInternalServerError, streamErr) + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when starting streaming via %s: %s", s.Transport.Type(), streamErr)) return } defer func() { if closeErr := streamData.Close(); closeErr != nil { - log.WithError(closeErr).Errorf("error when closing stream via %s", s.Transport.Type()) + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when closing stream via %s: %s", s.Transport.Type(), closeErr)) return } if stopErr := s.Transport.Stop(); stopErr != nil { - log.WithError(stopErr).Errorf("error when cleaning up stream via %s", s.Transport.Type()) + c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when cleaning up stream via %s: %s", s.Transport.Type(), stopErr)) return } }() @@ -139,7 +139,7 @@ forLoop: data := buffer[:n] if _, respWriteErr := writer.Write(data); respWriteErr != nil { if respWriteErr == io.EOF || respWriteErr == io.ErrUnexpectedEOF || respWriteErr == io.ErrClosedPipe { - log.Infoln("CAUGHT IO ERR") + log.Debugln("CAUGHT IO ERR") } log.WithError(respWriteErr).Errorln("Error while writing to connected stream client") break forLoop diff --git a/main.go b/main.go index 08a8740..b4533ed 100644 --- a/main.go +++ b/main.go @@ -94,7 +94,7 @@ func main() { log.Debugf("Loaded configuration %s", js) } - cc, err := context.NewCContext() + cc, err := context.NewCContext(log) if err != nil { log.WithError(err).Panicln("Couldn't create context") } From f28f1def9a716a477f094f6795db26fbb2e8a798 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 16:58:11 -0700 Subject: [PATCH 149/182] Remove static build options from .promu.yml since it breaks darwin/* --- .promu.yml | 6 +----- 1 file changed, 1 insertion(+), 5 deletions(-) diff --git a/.promu.yml b/.promu.yml index bfe7e6a..0245391 100644 --- a/.promu.yml +++ b/.promu.yml @@ -3,12 +3,8 @@ repository: go: cgo: true build: - flags: -a -tags 'netgo cgo static_build json1' + flags: -a -tags 'netgo json1' ldflags: | - -linkmode external - -w - -extldflags - -static -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} From e95bb84d2e4153dcc115db11e6857ca8c771f62d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 17:12:30 -0700 Subject: [PATCH 150/182] Update Dockerfile to specify path to database on a exposed volume and change expected config file name to just config --- Dockerfile | 6 +++++- main.go | 3 ++- 2 files changed, 7 insertions(+), 2 deletions(-) diff --git a/Dockerfile b/Dockerfile index c36a2cc..3bf6080 100644 --- a/Dockerfile +++ b/Dockerfile @@ -4,5 +4,9 @@ RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates mus COPY telly /bin/telly +USER nobody EXPOSE 6077 -ENTRYPOINT ["/bin/telly"] +VOLUME [ "/telly" ] +WORKDIR /telly +ENTRYPOINT [ "/bin/telly" ] +CMD [ "--database.file=/telly/telly.db" ] diff --git a/main.go b/main.go index b4533ed..97a22bb 100644 --- a/main.go +++ b/main.go @@ -60,9 +60,10 @@ func main() { if flag.Lookup("config.file").Changed { viper.SetConfigFile(flag.Lookup("config.file").Value.String()) } else { - viper.SetConfigName("telly.config") + viper.SetConfigName("config") viper.AddConfigPath("/etc/telly/") viper.AddConfigPath("$HOME/.telly") + viper.AddConfigPath("/telly") // Docker exposes this as a volume viper.AddConfigPath(".") viper.SetEnvPrefix(namespace) viper.AutomaticEnv() From bf09f2b8ac78a4b8556d3e4626d6432a484a6a6f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 17:34:35 -0700 Subject: [PATCH 151/182] Update Gopkg to upgrade go.xtream-codes version and fix squirrel constraint --- Gopkg.lock | 2 +- Gopkg.toml | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index c91340b..3005d96 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -363,7 +363,7 @@ name = "github.com/tellytv/go.xtream-codes" packages = ["."] pruneopts = "UT" - revision = "33a6daa3da5246cf599b2af0a3e2c19555ed560a" + revision = "24bf20fc23a2745a01dbd3829abc9bf52b55ef96" [[projects]] digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" diff --git a/Gopkg.toml b/Gopkg.toml index f755d40..0b80034 100644 --- a/Gopkg.toml +++ b/Gopkg.toml @@ -114,7 +114,7 @@ name = "golang.org/x/net" [[constraint]] - name = "github.com/Masterminds/squirrel" + name = "gopkg.in/Masterminds/squirrel.v1" version = "1.0" [prune] From 1a9ef91f248515927468e4fc8fca318ecccdf193 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 18:37:15 -0700 Subject: [PATCH 152/182] Improve the M3U stream URL regex --- internal/videoproviders/m3u.go | 14 ++++++++++---- internal/videoproviders/main.go | 2 +- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/internal/videoproviders/m3u.go b/internal/videoproviders/m3u.go index 372b66f..7eb9452 100644 --- a/internal/videoproviders/m3u.go +++ b/internal/videoproviders/m3u.go @@ -3,6 +3,7 @@ package videoproviders import ( "fmt" "strconv" + "strings" "github.com/tellytv/telly/internal/m3uplus" "github.com/tellytv/telly/internal/utils" @@ -70,15 +71,20 @@ func (m *M3U) Refresh() error { m.Playlist = playlist for _, track := range playlist.Tracks { - streamURL := streamNumberRegex(track.URI, -1)[0] + streamURL := streamNumberRegex(strings.ToLower(track.URI), -1) - channelID, channelIDErr := strconv.Atoi(streamURL[1]) + if len(streamURL) == 0 { + fmt.Println("Unable to process M3U track, continuing", track.URI) + continue + } + + channelID, channelIDErr := strconv.Atoi(streamURL[0][1]) if channelIDErr != nil { return fmt.Errorf("error when extracting channel id from m3u track: %s", channelIDErr) } - if !utils.Contains(m.seenFormats, streamURL[2]) { - m.seenFormats = append(m.seenFormats, streamURL[2]) + if !utils.Contains(m.seenFormats, streamURL[0][2]) { + m.seenFormats = append(m.seenFormats, streamURL[0][2]) } nameVal := track.Name diff --git a/internal/videoproviders/main.go b/internal/videoproviders/main.go index 7001cec..fe7e2c6 100644 --- a/internal/videoproviders/main.go +++ b/internal/videoproviders/main.go @@ -6,7 +6,7 @@ import ( "strings" ) -var streamNumberRegex = regexp.MustCompile(`/(\d+).(ts|.*.m3u8)`).FindAllStringSubmatch +var streamNumberRegex = regexp.MustCompile(`/(\d+).(mp4|mkv|avi|ts|.*.m3u8)`).FindAllStringSubmatch // var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString // var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString From ff33dbd1f55782c0ab0af683afc912d815d82b99 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 18:41:43 -0700 Subject: [PATCH 153/182] Fix Viper envars --- main.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/main.go b/main.go index 97a22bb..a99c8d2 100644 --- a/main.go +++ b/main.go @@ -6,6 +6,7 @@ import ( "fmt" "net" "os" + "strings" "github.com/prometheus/common/version" "github.com/robfig/cron" @@ -65,6 +66,7 @@ func main() { viper.AddConfigPath("$HOME/.telly") viper.AddConfigPath("/telly") // Docker exposes this as a volume viper.AddConfigPath(".") + viper.SetEnvKeyReplacer(strings.NewReplacer(".", "_")) viper.SetEnvPrefix(namespace) viper.AutomaticEnv() } From afb00b8923ec09d3eed1101fe33eb931b2e1f2aa Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 18:56:42 -0700 Subject: [PATCH 154/182] Install tzdata --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index 3bf6080..c491502 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,6 @@ FROM jrottenberg/ffmpeg:4.0-alpine -RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev +RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev tzdata COPY telly /bin/telly From d04f32ab8a05efd9a0c0a1ffa2d94842eacc058f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 19:38:23 -0700 Subject: [PATCH 155/182] Revert "Install tzdata" This reverts commit afb00b8923ec09d3eed1101fe33eb931b2e1f2aa. --- Dockerfile | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Dockerfile b/Dockerfile index c491502..3bf6080 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,6 +1,6 @@ FROM jrottenberg/ffmpeg:4.0-alpine -RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev tzdata +RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev COPY telly /bin/telly From 4fe46d2d75abb6e974346e9f6ba01d4015127b47 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 19:39:06 -0700 Subject: [PATCH 156/182] Bump Xtream version to remove zoneinfo dep --- Gopkg.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index 3005d96..f277ff4 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -359,11 +359,11 @@ [[projects]] branch = "master" - digest = "1:e51bee2c46f96d430b7f23e2824cd61c5ad2229b50d6618b0f1132e7947f4d54" + digest = "1:03cf379b75fbd215a1b0259db2b4ed517f0741f5bcac6a7c17c8c75acd97d71d" name = "github.com/tellytv/go.xtream-codes" packages = ["."] pruneopts = "UT" - revision = "24bf20fc23a2745a01dbd3829abc9bf52b55ef96" + revision = "c42c5900a05a107a25b8d22970223f515532bee7" [[projects]] digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" From f8182c1823ae10b76daa628fe2496b54e4f8a693 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 19:52:53 -0700 Subject: [PATCH 157/182] Fix WHERE IN queries --- internal/models/lineup_channel.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/internal/models/lineup_channel.go b/internal/models/lineup_channel.go index 1a76898..b6a0ed4 100644 --- a/internal/models/lineup_channel.go +++ b/internal/models/lineup_channel.go @@ -226,11 +226,13 @@ func (db *LineupChannelDB) GetEnabledChannelsForGuideProvider(providerID int) ([ inQuery := squirrel.Select("id").From("guide_source_channel").Where(squirrel.Eq{"guide_id": providerID}) // Using DebugSqlizer is unsafe but Squirrel doesn't support WHERE IN subqueries. - sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(squirrel.Eq{"guide_channel_id": squirrel.DebugSqlizer(inQuery)}).ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(fmt.Sprintf("guide_channel_id IN (%s)", squirrel.DebugSqlizer(inQuery))).ToSql() if sqlGenErr != nil { return nil, sqlGenErr } + fmt.Println(sql, args) + err := db.SQL.Select(&channels, sql, args...) if err != nil { return nil, err @@ -258,7 +260,7 @@ func (db *LineupChannelDB) GetEnabledChannelsForVideoProvider(providerID int) ([ inQuery := squirrel.Select("id").From("video_source_track").Where(squirrel.Eq{"video_source_id": providerID}) // Using DebugSqlizer is unsafe but Squirrel doesn't support WHERE IN subqueries. - sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(squirrel.Eq{"video_track_id": squirrel.DebugSqlizer(inQuery)}).ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("lineup_channel").Where(fmt.Sprintf("video_track_id IN (%s)", squirrel.DebugSqlizer(inQuery))).ToSql() if sqlGenErr != nil { return nil, sqlGenErr } From 6c7476febacbf3322fca8a7fd87415d6e3afc88e Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 20:13:06 -0700 Subject: [PATCH 158/182] Improve API logging --- internal/api/guide_source.go | 3 +++ internal/api/utils.go | 2 +- 2 files changed, 4 insertions(+), 1 deletion(-) diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index afc1a94..f586b40 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -17,6 +17,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { if c.BindJSON(&payload) == nil { newGuide, providerErr := cc.API.GuideSource.InsertGuideSource(payload, nil) if providerErr != nil { + log.WithError(providerErr).Errorln("error inserting guide source") c.AbortWithError(http.StatusInternalServerError, providerErr) return } @@ -25,6 +26,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { provider, providerErr := providerCfg.GetProvider() if providerErr != nil { + log.WithError(providerErr).Errorln("Error getting provider") c.AbortWithError(http.StatusInternalServerError, providerErr) return } @@ -35,6 +37,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { lineupMetadata, reloadErr := provider.Refresh(nil) if reloadErr != nil { + log.WithError(reloadErr).Errorln("Error refreshing provider") c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while initializing guide data provider: %s", reloadErr)) return } diff --git a/internal/api/utils.go b/internal/api/utils.go index 7aa9035..f931d98 100644 --- a/internal/api/utils.go +++ b/internal/api/utils.go @@ -73,7 +73,7 @@ func ginrus(cc *context.CContext) gin.HandlerFunc { if len(c.Errors) > 0 { // Append error field if this is an erroneous request. - entry.Error(c.Errors.String()) + entry.Errorln(c.Errors.String()) } else { entry.Info() } From 811ea6be581f9bc8f2956d7c3892f2754b948e4d Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 6 Sep 2018 20:13:18 -0700 Subject: [PATCH 159/182] Properly map the XMLTV_URL to URL --- internal/models/guide_source.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/models/guide_source.go b/internal/models/guide_source.go index 1133d18..94300c4 100644 --- a/internal/models/guide_source.go +++ b/internal/models/guide_source.go @@ -38,7 +38,7 @@ type GuideSource struct { Provider string `db:"provider"` Username string `db:"username"` Password string `db:"password"` - URL string `db:"xmltv_url"` + URL string `db:"xmltv_url" json:"XMLTV_URL"` ProviderData json.RawMessage `db:"provider_data"` UpdateFrequency string `db:"update_frequency"` ImportedAt *time.Time `db:"imported_at"` From 7f69fc5618e071f61cf873bb14cc8bbf931e27eb Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 11 Sep 2018 18:59:11 -0700 Subject: [PATCH 160/182] remove broken pause implementation, pass context all the way through the transports --- internal/streamsuite/stream.go | 95 ++++++------------------------ internal/streamsuite/transports.go | 12 ++-- 2 files changed, 24 insertions(+), 83 deletions(-) diff --git a/internal/streamsuite/stream.go b/internal/streamsuite/stream.go index 3894546..1e2cb41 100644 --- a/internal/streamsuite/stream.go +++ b/internal/streamsuite/stream.go @@ -10,7 +10,6 @@ import ( "time" "github.com/gin-gonic/gin" - "github.com/prometheus/client_golang/prometheus" "github.com/sirupsen/logrus" "github.com/tellytv/telly/internal/metrics" "github.com/tellytv/telly/internal/models" @@ -39,67 +38,33 @@ type Stream struct { StreamURL string Transport StreamTransport - Paused bool - PausedAt *time.Time StartTime *time.Time PromLabels []string - PlayTimer *prometheus.Timer `json:"-"` - PauseTimer *prometheus.Timer `json:"-"` - StopNow chan bool `json:"-"` + StopNow chan bool `json:"-"` LastWroteAt *time.Time + + streamData io.ReadCloser } // Start will mark the stream as playing and begin playback. func (s *Stream) Start(c *gin.Context) { + ctx := c.Request.Context() + now := time.Now() - s.LastWroteAt = &now s.StartTime = &now metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Inc() - s.PlayTimer = prometheus.NewTimer(prometheus.ObserverFunc(func(v float64) { - metrics.StreamPlayingTime.WithLabelValues(s.PromLabels...).Observe(v) - })) - - s.PauseTimer = prometheus.NewTimer(prometheus.ObserverFunc(func(v float64) { - metrics.StreamPausedTime.WithLabelValues(s.PromLabels...).Observe(v) - })) - - streamData, streamErr := s.Transport.Start(s.StreamURL) + log.Infoln("Transcoding stream with", s.Transport.Type()) + sd, streamErr := s.Transport.Start(ctx, s.StreamURL) if streamErr != nil { c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when starting streaming via %s: %s", s.Transport.Type(), streamErr)) return } - defer func() { - if closeErr := streamData.Close(); closeErr != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when closing stream via %s: %s", s.Transport.Type(), closeErr)) - return - } - - if stopErr := s.Transport.Stop(); stopErr != nil { - c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when cleaning up stream via %s: %s", s.Transport.Type(), stopErr)) - return - } - }() + s.streamData = sd clientGone := c.Writer.CloseNotify() - go func() { - for { - // Keep the Prometheus timer updated - if !s.Paused { - s.PlayTimer.ObserveDuration() - } else { - s.PauseTimer.ObserveDuration() - } - - // We wait at least 2 full seconds before declaring that a stream is paused. - if time.Since(*s.LastWroteAt) > 2*time.Second { - s.Pause() - } - } - }() - for key, value := range s.Transport.Headers() { c.Writer.Header()[key] = value } @@ -114,28 +79,22 @@ forLoop: case <-s.StopNow: break forLoop case <-clientGone: + case <-ctx.Done(): log.Debugln("Stream client is disconnected, returning!") - s.Stop() break forLoop default: - n, err := streamData.Read(buffer) + n, err := s.streamData.Read(buffer) if n == 0 { log.Debugln("Read 0 bytes from stream source, returning") - s.Unpause(false) break forLoop } if err != nil { log.WithError(err).Errorln("Received error while reading from stream source") - s.Unpause(false) break forLoop } - now := time.Now() - s.LastWroteAt = &now - s.Unpause(true) - data := buffer[:n] if _, respWriteErr := writer.Write(data); respWriteErr != nil { if respWriteErr == io.EOF || respWriteErr == io.ErrUnexpectedEOF || respWriteErr == io.ErrClosedPipe { @@ -148,39 +107,19 @@ forLoop: } } -} + s.Stop() -// Pause will cause the stream to pause playback. -func (s *Stream) Pause() { - if !s.Paused { - s.Paused = true - now := time.Now() - s.PausedAt = &now - metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Dec() - metrics.PausedStreams.WithLabelValues(s.PromLabels...).Inc() - } -} - -// Unpause will resume playback. -func (s *Stream) Unpause(increaseActiveStreams bool) { - if s.Paused { - s.Paused = false - s.PausedAt = nil - metrics.PausedStreams.WithLabelValues(s.PromLabels...).Dec() - if increaseActiveStreams { - metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Inc() - } - } } // Stop will tear down the stream. func (s *Stream) Stop() { - if s.Paused { - metrics.PausedStreams.WithLabelValues(s.PromLabels...).Dec() - } else { - metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Dec() + metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Dec() + + if closeErr := s.streamData.Close(); closeErr != nil { + log.WithError(closeErr).Errorf("error when closing stream via %s", s.Transport.Type()) + return } - s.Paused = false + if stopErr := s.Transport.Stop(); stopErr != nil { log.WithError(stopErr).Errorf("error when cleaning up stream via %s", s.Transport.Type()) return diff --git a/internal/streamsuite/transports.go b/internal/streamsuite/transports.go index 3ed3130..452d8cc 100644 --- a/internal/streamsuite/transports.go +++ b/internal/streamsuite/transports.go @@ -1,6 +1,7 @@ package streamsuite import ( + "context" "encoding/json" "fmt" "io" @@ -14,7 +15,7 @@ import ( type StreamTransport interface { Type() string Headers() http.Header - Start(streamURL string) (io.ReadCloser, error) + Start(ctx context.Context, streamURL string) (io.ReadCloser, error) Stop() error } @@ -39,9 +40,8 @@ func (f FFMPEG) Headers() http.Header { } // Start will begin the stream. -func (f FFMPEG) Start(streamURL string) (io.ReadCloser, error) { - log.Infoln("Transcoding stream with ffmpeg") - f.run = exec.Command("ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") // nolint +func (f FFMPEG) Start(ctx context.Context, streamURL string) (io.ReadCloser, error) { + f.run = exec.CommandContext(ctx, "ffmpeg", "-re", "-i", streamURL, "-codec", "copy", "-f", "mpegts", "-tune", "zerolatency", "pipe:1") // nolint streamData, stdErr := f.run.StdoutPipe() if stdErr != nil { return nil, stdErr @@ -84,12 +84,14 @@ func (h HTTP) Headers() http.Header { } // Start will begin the stream. -func (h *HTTP) Start(streamURL string) (io.ReadCloser, error) { +func (h *HTTP) Start(ctx context.Context, streamURL string) (io.ReadCloser, error) { streamReq, reqErr := http.NewRequest("GET", streamURL, nil) if reqErr != nil { return nil, reqErr } + streamReq = streamReq.WithContext(ctx) + streamReq.Header.Set("User-Agent", fmt.Sprintf("telly/%s", version.Version)) h.req = streamReq From b66db1b8f90ab8658326f77833a2dabcd46a126f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 11 Sep 2018 19:46:28 -0700 Subject: [PATCH 161/182] minor sql fixes --- internal/models/guide_source_programme.go | 2 +- internal/models/lineup_channel.go | 2 -- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/internal/models/guide_source_programme.go b/internal/models/guide_source_programme.go index 223791e..c55598d 100644 --- a/internal/models/guide_source_programme.go +++ b/internal/models/guide_source_programme.go @@ -142,7 +142,7 @@ func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID string, // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) ORDER BY start ASC").ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel))").OrderBy("start ASC").ToSql() if sqlGenErr != nil { return nil, sqlGenErr } diff --git a/internal/models/lineup_channel.go b/internal/models/lineup_channel.go index b6a0ed4..f6368c1 100644 --- a/internal/models/lineup_channel.go +++ b/internal/models/lineup_channel.go @@ -231,8 +231,6 @@ func (db *LineupChannelDB) GetEnabledChannelsForGuideProvider(providerID int) ([ return nil, sqlGenErr } - fmt.Println(sql, args) - err := db.SQL.Select(&channels, sql, args...) if err != nil { return nil, err From 8aac7173b62d92dfc5b532bd93814afe6b6a98d8 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 11 Sep 2018 19:46:58 -0700 Subject: [PATCH 162/182] expose telly version in xmltv header --- internal/api/xmltv.go | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/internal/api/xmltv.go b/internal/api/xmltv.go index 8a69581..8263529 100644 --- a/internal/api/xmltv.go +++ b/internal/api/xmltv.go @@ -9,6 +9,7 @@ import ( "time" "github.com/gin-gonic/gin" + "github.com/prometheus/common/version" "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/guideproviders" "github.com/tellytv/telly/internal/xmltv" @@ -17,8 +18,8 @@ import ( func xmlTV(cc *context.CContext, c *gin.Context) { epg := &xmltv.TV{ Date: time.Now().Format("2006-01-02"), - GeneratorInfoName: "telly", - GeneratorInfoURL: "https://github.com/tellytv/telly/internal", + GeneratorInfoName: fmt.Sprintf("telly/%s", version.Version), + GeneratorInfoURL: "https://github.com/tellytv/telly", } lineups, lineupsErr := cc.API.Lineup.GetEnabledLineups(true) From 5d61aa56231a40aa395b7079c38d4d6865b5dd0f Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Tue, 11 Sep 2018 19:47:35 -0700 Subject: [PATCH 163/182] fixes to SD guide updates --- internal/guideproviders/schedules_direct.go | 19 +++++++++++-------- 1 file changed, 11 insertions(+), 8 deletions(-) diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 7998be2..cf71f25 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -359,7 +359,9 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input return a < b }) - programme, programmeErr := s.processProgrammeToXMLTV(airing, extendedProgramInfo[airing.ProgramID], artworks, station) + extendedInfo := extendedProgramInfo[airing.ProgramID] + + programme, programmeErr := s.processProgrammeToXMLTV(&airing, &extendedInfo, artworks, &station) if programmeErr != nil { return nil, nil, fmt.Errorf("error while processing schedules direct result to xmltv format: %s", programmeErr) } @@ -464,12 +466,13 @@ func (s *SchedulesDirect) Refresh(lastStatusJSON []byte) ([]byte, error) { for _, entry := range channels.Map { if val, ok := stationsMap[entry.StationID]; ok { - val.ChannelMap = entry - stationsMap[entry.StationID] = val + stationsMap[entry.StationID] = sdStationContainer{Station: val.Station, ChannelMap: entry} } } - s.stations = make(map[string]sdStationContainer) + if s.stations == nil { + s.stations = make(map[string]sdStationContainer) + } if s.channels == nil { s.channels = make([]Channel, 0) @@ -582,7 +585,7 @@ type sdProgrammeData struct { Station sdStationContainer } -func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program, programInfo schedulesdirect.ProgramInfo, allArtwork []schedulesdirect.Artwork, station sdStationContainer) (*ProgrammeContainer, error) { +func (s *SchedulesDirect) processProgrammeToXMLTV(airing *schedulesdirect.Program, programInfo *schedulesdirect.ProgramInfo, allArtwork []schedulesdirect.Artwork, station *sdStationContainer) (*ProgrammeContainer, error) { stationID := fmt.Sprintf("I%s.%s.schedulesdirect.org", station.ChannelMap.Channel, station.Station.StationID) endTime := airing.AirDateTime.Add(time.Duration(airing.Duration) * time.Second) length := xmltv.Length{Units: "seconds", Value: strconv.Itoa(airing.Duration)} @@ -840,10 +843,10 @@ func (s *SchedulesDirect) processProgrammeToXMLTV(airing schedulesdirect.Program return &ProgrammeContainer{ Programme: xmlProgramme, ProviderData: sdProgrammeData{ - airing, - programInfo, + *airing, + *programInfo, allArtwork, - station, + *station, }, }, nil From eae9fd86987104fc75be273d5dd746144b057d43 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 12 Sep 2018 17:49:36 -0700 Subject: [PATCH 164/182] Improve error logging and pass source stream errors up --- internal/api/utils.go | 14 +++++------- internal/streamsuite/stream.go | 6 ++++- internal/streamsuite/transports.go | 35 +++++++++++++++++++++++++++--- 3 files changed, 42 insertions(+), 13 deletions(-) diff --git a/internal/api/utils.go b/internal/api/utils.go index f931d98..022ec6e 100644 --- a/internal/api/utils.go +++ b/internal/api/utils.go @@ -69,13 +69,12 @@ func ginrus(cc *context.CContext) gin.HandlerFunc { "time": end.Format(time.RFC3339), } - entry := cc.Log.WithFields(logFields) - if len(c.Errors) > 0 { // Append error field if this is an erroneous request. - entry.Errorln(c.Errors.String()) - } else { - entry.Info() + logFields["error"] = c.Errors.String() + cc.Log.WithFields(logFields).Errorln("Error while serving request") + } else if viper.GetBool("log.requests") { + cc.Log.WithFields(logFields).Infoln() } } } @@ -107,10 +106,7 @@ func newGin(cc *context.CContext) *gin.Engine { router := gin.New() router.Use(cors.Default()) router.Use(gin.Recovery()) - - if viper.GetBool("log.requests") { - router.Use(ginrus(cc)) - } + router.Use(ginrus(cc)) prom.Use(router) return router diff --git a/internal/streamsuite/stream.go b/internal/streamsuite/stream.go index 1e2cb41..debb12f 100644 --- a/internal/streamsuite/stream.go +++ b/internal/streamsuite/stream.go @@ -54,9 +54,13 @@ func (s *Stream) Start(c *gin.Context) { s.StartTime = &now metrics.ActiveStreams.WithLabelValues(s.PromLabels...).Inc() - log.Infoln("Transcoding stream with", s.Transport.Type()) + log.Infoln("Transcoding stream via", s.Transport.Type()) sd, streamErr := s.Transport.Start(ctx, s.StreamURL) if streamErr != nil { + if httpErr, ok := streamErr.(httpError); ok { + c.AbortWithError(httpErr.StatusCode, httpErr) + return + } c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error when starting streaming via %s: %s", s.Transport.Type(), streamErr)) return } diff --git a/internal/streamsuite/transports.go b/internal/streamsuite/transports.go index 452d8cc..2ae6c60 100644 --- a/internal/streamsuite/transports.go +++ b/internal/streamsuite/transports.go @@ -1,6 +1,7 @@ package streamsuite import ( + "bytes" "context" "encoding/json" "fmt" @@ -87,7 +88,7 @@ func (h HTTP) Headers() http.Header { func (h *HTTP) Start(ctx context.Context, streamURL string) (io.ReadCloser, error) { streamReq, reqErr := http.NewRequest("GET", streamURL, nil) if reqErr != nil { - return nil, reqErr + return nil, newHTTPError(reqErr, http.StatusInternalServerError, nil) } streamReq = streamReq.WithContext(ctx) @@ -98,13 +99,13 @@ func (h *HTTP) Start(ctx context.Context, streamURL string) (io.ReadCloser, erro resp, respErr := http.DefaultClient.Do(streamReq) if respErr != nil { - return nil, respErr + return nil, newHTTPError(respErr, 0, nil) } h.resp = resp if resp.StatusCode > 399 { - return nil, fmt.Errorf("unexpected status code %d", resp.StatusCode) + return nil, newHTTPError(nil, resp.StatusCode, resp.Body) } return resp.Body, nil @@ -114,3 +115,31 @@ func (h *HTTP) Start(ctx context.Context, streamURL string) (io.ReadCloser, erro func (h HTTP) Stop() error { return nil } + +type httpError struct { + OriginalError error + StatusCode int + Contents string +} + +func newHTTPError(err error, code int, reader io.ReadCloser) httpError { + buf := &bytes.Buffer{} + if reader != nil { + if _, copyErr := io.Copy(buf, reader); copyErr != nil { + return httpError{OriginalError: err, StatusCode: code} + } + } + + return httpError{ + OriginalError: err, + StatusCode: code, + Contents: buf.String(), + } +} + +func (h httpError) Error() string { + if h.OriginalError != nil { + return h.OriginalError.Error() + } + return fmt.Sprintf("unexpected status code %d, received contents: %s", h.StatusCode, h.Contents) +} From 924bdf3c2051b45631ce745f6a7db2b6cce91671 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 12 Sep 2018 18:22:40 -0700 Subject: [PATCH 165/182] Fix XMLTV issues --- internal/guideproviders/main.go | 3 +- internal/guideproviders/schedules_direct.go | 6 ++-- internal/guideproviders/xmltv.go | 3 +- internal/models/guide_source.go | 31 +++++++++++++-------- 4 files changed, 27 insertions(+), 16 deletions(-) diff --git a/internal/guideproviders/main.go b/internal/guideproviders/main.go index b89ce70..70526e6 100644 --- a/internal/guideproviders/main.go +++ b/internal/guideproviders/main.go @@ -3,6 +3,7 @@ package guideproviders import ( + "encoding/json" "strings" "github.com/tellytv/telly/internal/xmltv" @@ -122,7 +123,7 @@ type GuideProvider interface { Channels() ([]Channel, error) Schedule(daysToGet int, inputChannels []Channel, inputProgrammes []ProgrammeContainer) (map[string]interface{}, []ProgrammeContainer, error) - Refresh(lineupStateJSON []byte) ([]byte, error) + Refresh(lastStatusJSON *json.RawMessage) ([]byte, error) Configuration() Configuration // Schedules Direct specific functions that others might someday use. diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index cf71f25..cdf4756 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -373,7 +373,7 @@ func (s *SchedulesDirect) Schedule(daysToGet int, inputChannels []Channel, input } // Refresh causes the provider to request the latest information. -func (s *SchedulesDirect) Refresh(lastStatusJSON []byte) ([]byte, error) { +func (s *SchedulesDirect) Refresh(lastStatusJSON *json.RawMessage) ([]byte, error) { if s.client == nil { sdClient, sdClientErr := schedulesdirect.NewClient(s.BaseConfig.Username, s.BaseConfig.Password) if sdClientErr != nil { @@ -385,8 +385,8 @@ func (s *SchedulesDirect) Refresh(lastStatusJSON []byte) ([]byte, error) { lineupsMetadataMap := make(map[string]schedulesdirect.Lineup) var lastStatus schedulesdirect.StatusResponse - if len(lastStatusJSON) > 0 { - if unmarshalErr := json.Unmarshal(lastStatusJSON, &lastStatus); unmarshalErr != nil { + if len(*lastStatusJSON) > 0 { + if unmarshalErr := json.Unmarshal(*lastStatusJSON, &lastStatus); unmarshalErr != nil { return nil, fmt.Errorf("error unmarshalling cached status JSON: %s", unmarshalErr) } diff --git a/internal/guideproviders/xmltv.go b/internal/guideproviders/xmltv.go index 2204429..732d000 100644 --- a/internal/guideproviders/xmltv.go +++ b/internal/guideproviders/xmltv.go @@ -1,6 +1,7 @@ package guideproviders import ( + "encoding/json" "fmt" "github.com/tellytv/telly/internal/utils" @@ -84,7 +85,7 @@ func (x *XMLTV) Schedule(daysToGet int, inputChannels []Channel, inputProgrammes } // Refresh causes the provider to request the latest information. -func (x *XMLTV) Refresh(lineupStateJSON []byte) ([]byte, error) { +func (x *XMLTV) Refresh(lastStatusJSON *json.RawMessage) ([]byte, error) { xTV, xTVErr := utils.GetXMLTV(x.BaseConfig.XMLTVURL) if xTVErr != nil { return nil, fmt.Errorf("error when getting XMLTV file: %s", xTVErr) diff --git a/internal/models/guide_source.go b/internal/models/guide_source.go index 94300c4..199e6d3 100644 --- a/internal/models/guide_source.go +++ b/internal/models/guide_source.go @@ -33,15 +33,15 @@ func (db *GuideSourceDB) tableName() string { // GuideSource describes a source of EPG data. type GuideSource struct { - ID int `db:"id"` - Name string `db:"name"` - Provider string `db:"provider"` - Username string `db:"username"` - Password string `db:"password"` - URL string `db:"xmltv_url" json:"XMLTV_URL"` - ProviderData json.RawMessage `db:"provider_data"` - UpdateFrequency string `db:"update_frequency"` - ImportedAt *time.Time `db:"imported_at"` + ID int `db:"id"` + Name string `db:"name"` + Provider string `db:"provider"` + Username string `db:"username"` + Password string `db:"password"` + URL string `db:"xmltv_url" json:"XMLTV_URL"` + ProviderData *json.RawMessage `db:"provider_data"` + UpdateFrequency string `db:"update_frequency"` + ImportedAt *time.Time `db:"imported_at"` Channels []GuideSourceChannel `db:"-"` } @@ -89,7 +89,13 @@ func (db *GuideSourceDB) InsertGuideSource(guideSourceStruct GuideSource, provid return nil, fmt.Errorf("error when marshalling providerData for use in guide_source_programme insert: %s", providerDataJSONErr) } - guideSourceStruct.ProviderData = providerDataJSON + rawJSON := json.RawMessage(providerDataJSON) + + guideSourceStruct.ProviderData = &rawJSON + + if guideSourceStruct.UpdateFrequency == "" { + guideSourceStruct.UpdateFrequency = "@daily" + } res, err := db.SQL.NamedExec(` INSERT INTO guide_source (name, provider, username, password, xmltv_url, provider_data, update_frequency) @@ -133,6 +139,9 @@ func (db *GuideSourceDB) UpdateGuideSource(guideSourceID int, providerData inter func (db *GuideSourceDB) GetAllGuideSources(includeChannels bool) ([]GuideSource, error) { sources := make([]GuideSource, 0) err := db.SQL.Select(&sources, baseGuideSourceQuery) + if err != nil { + return nil, err + } if includeChannels { newSources := make([]GuideSource, 0) for _, source := range sources { @@ -145,7 +154,7 @@ func (db *GuideSourceDB) GetAllGuideSources(includeChannels bool) ([]GuideSource } return newSources, nil } - return sources, err + return sources, nil } // GetGuideSourcesForLineup returns a slice of GuideSource for the given lineup ID. From 7f6bd25b6d4dab20871c4fd311cf98b4fe82f113 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 12 Sep 2018 18:24:49 -0700 Subject: [PATCH 166/182] Update frontend --- frontend | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frontend b/frontend index 23d8d0a..edcc7b0 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 23d8d0a7cc44611486a2a8d47e115acf88f8f2cf +Subproject commit edcc7b0535a0ab73fd86ba4b50e571801cbb97b2 From f94203eb754627cc04e882b219294b57797cdcc7 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Wed, 12 Sep 2018 18:31:59 -0700 Subject: [PATCH 167/182] Update frontend. Fixes #196 --- frontend | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frontend b/frontend index edcc7b0..ad6c1a1 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit edcc7b0535a0ab73fd86ba4b50e571801cbb97b2 +Subproject commit ad6c1a1a6a3737f61bad0eb248fc0c8dccc43c81 From 6b9a78c2296d30bec94a1917a58dde9319c732d4 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Thu, 13 Sep 2018 14:48:09 -0700 Subject: [PATCH 168/182] Get video source updates working --- internal/api/a_api-packr.go | 2 +- internal/commands/video_updates.go | 31 ++++++++++++++++--- internal/context/a_context-packr.go | 1 + internal/context/context.go | 4 ++- internal/models/video_source.go | 5 +++ internal/models/video_source_track.go | 11 +++---- ...13140221-AddVideoTrackUniqueConstraint.sql | 6 ++++ 7 files changed, 47 insertions(+), 13 deletions(-) create mode 100644 migrations/20180913140221-AddVideoTrackUniqueConstraint.sql diff --git a/internal/api/a_api-packr.go b/internal/api/a_api-packr.go index b3573eb..6e15397 100644 --- a/internal/api/a_api-packr.go +++ b/internal/api/a_api-packr.go @@ -12,7 +12,7 @@ func init() { packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"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\"") packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") + packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") diff --git a/internal/commands/video_updates.go b/internal/commands/video_updates.go index d9d392f..5f98157 100644 --- a/internal/commands/video_updates.go +++ b/internal/commands/video_updates.go @@ -11,15 +11,36 @@ import ( func FireVideoUpdatesCommand() { cc, err := context.NewCContext(nil) if err != nil { - panic(fmt.Errorf("couldn't create context: %s", err)) + log.WithError(err).Errorf("couldn't create context") } if err = fireVideoUpdates(cc, nil); err != nil { - panic(fmt.Errorf("could not complete video updates: %s", err)) + log.WithError(err).Errorf("could not complete video updates") } } func fireVideoUpdates(cc *context.CContext, provider *models.VideoSource) error { - fmt.Println("VIDEO source update is beginning") + log.Debugf("Video source update is beginning for provider", provider.Name) + + channels, channelsErr := cc.VideoSourceProviders[provider.ID].Channels() + if channelsErr != nil { + return fmt.Errorf("error while getting video channels during update of %s: %s", provider.Name, channelsErr) + } + + for _, channel := range channels { + newTrackErr := cc.API.VideoSourceTrack.UpdateVideoSourceTrack(provider.ID, channel.StreamID, models.VideoSourceTrack{ + VideoSourceID: provider.ID, + Name: channel.Name, + StreamID: channel.StreamID, + Logo: channel.Logo, + Type: string(channel.Type), + Category: channel.Category, + EPGID: channel.EPGID, + }) + if newTrackErr != nil { + return fmt.Errorf("error while inserting video track (source id: %d stream id: %d name: %s) during update: %s", provider.ID, channel.StreamID, channel.Name, newTrackErr) + } + } + return nil } @@ -27,8 +48,8 @@ func fireVideoUpdates(cc *context.CContext, provider *models.VideoSource) error func StartFireVideoUpdates(cc *context.CContext, provider *models.VideoSource) { err := fireVideoUpdates(cc, provider) if err != nil { - panic(fmt.Errorf("could not complete video updates: %s", err.Error())) + log.WithError(err).Errorln("could not complete video updates for provider", provider.Name) } - fmt.Println("Video source has been updated successfully") + log.Infof("Video source %s has been updated successfully", provider.Name) } diff --git a/internal/context/a_context-packr.go b/internal/context/a_context-packr.go index a0264ad..36bdd56 100644 --- a/internal/context/a_context-packr.go +++ b/internal/context/a_context-packr.go @@ -8,5 +8,6 @@ import "github.com/gobuffalo/packr" // and any other packr generated files. func init() { packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXSW/jNhS+61fwFhu1g8TZZjCXKjY9EerIqUwVmZPAERmbqCRquDjjf19Ym0lZSt2gRYDqyPe97XsLKWc8Br+kbC2woiDMHWcaQBdBgNz7BQTeHPhLBOCzt0IrsGWE8khyLWIKBg4AjAD783wEv8IAPAXeoxt8A7/Bb8AN0dLzpwF8hD4aOQBkOKWWFoLPhSAXfO9CNII/3GD64AaD2+sh8MPFYg/SkgrLQhcox1K+ckHeBH3HkkZaJEdxpFfaOj8I8M9IKkFxKq18i7hyghWNXgT9oWkW7wolMINzN1wgcPYrwSzZne2RLM25UJREWFXmvUe4Qu7jUwOfhkEAfRQ1Emf45eTSRErg+M/OAp1UH8sWI2aS7dLVxJSkRI07QyXha96lonZ5p6kYK7rmYtc+p/k6MtOpz9tsnkDmyHEAmC8D6H319xQMWhkPQQDnMID+FNrMDhgZ/l0l1poR+v8Zkp9porbmNLTjiAhW2BR87CCY9EfxBmcZTd4/CqW1g6rR1yUxB1EfL/V5TdO/1b/Tpb9Cgev5CFRpRjpjPzQFoe/9HkIwqIMfNbEOR63GryFWx5sU/tOOj3LB1wKnadn7HfwVM17V5XiNYKFMjg4ZA0Azu4KWcN9ypnDmIvhB1WgY6K9Hlf+oTHi0T+2/KU3CMqrz7jX07k1kFkySvC27Xy4X0PUbwlAQFqVImFQ0izAhgkp5sHNYDZeTu/OL84vzy2I7ECZjvqViZ6i8hd8XrifB4r7RGRWyV5ziTL/gWGlxWK22txVLWMwzoqUq/KWc0CSy2bE1HmYPPKWBzgB8RtCfmWo6/d7n6GGGpuNJuCrgL0ykr1hQ05EN35ANT6nQmYojrGRsq22pkIxnx2qTi8ubi0+T25JrumUxte7XI66vrm9u7z6ZcKzVpgeuaFIt+QqrtWG82/TYhRN3fA1vrsf399PP46srd343u5ndup8nZ8YrQwmcybraLS6UygtoLCg2b5YTZ/m0eXrzXjltqCpDnTeLYirpfhpVe75pnlpQvlGKZ19p0rBWroxa1X7ObdqxV7NbdBDecsGMrWrIjth9z6OrocDacOXpoOOuspPsfaOViC4DbSZ6N2uNaTas9ZM046+Z48yC5VPVIqb3L32CMixLbLrsFdSxWICSpI6jA/qvAAAA//+mYnMb2A0AAA==\"") + packr.PackJSONBytes("../../migrations", "20180913140221-AddVideoTrackUniqueConstraint.sql", "\"H4sIAAAAAAAA/+LS1VXQzs1ML0osSVUILeDicg5ydQxxVQj18wwMdVXw9HNxjVAoKUpMzo4vzcssLE1V8PdTKMtMSc2PL84vLUpOjQdLaqAIZaboKBSXFKUm5sZnpmhac6FY4pJfnscFCAAA//+8qzXOdwAAAA==\"") packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") } diff --git a/internal/context/context.go b/internal/context/context.go index 042679c..4049f56 100644 --- a/internal/context/context.go +++ b/internal/context/context.go @@ -81,7 +81,9 @@ func NewCContext(log *logrus.Logger) (*CContext, error) { if upErr != nil { log.WithError(upErr).Panicln("error migrating database to newer version") } - log.Debugf("successfully applied %d migrations to database", numMigrations) + if numMigrations > 0 { + log.Debugf("successfully applied %d migrations to database", numMigrations) + } api := models.NewAPICollection(sql, log) diff --git a/internal/models/video_source.go b/internal/models/video_source.go index 90f3a34..9ced8f7 100644 --- a/internal/models/video_source.go +++ b/internal/models/video_source.go @@ -83,6 +83,11 @@ SELECT // InsertVideoSource inserts a new VideoSource into the database. func (db *VideoSourceDB) InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) { videoSource := VideoSource{} + + if videoSourceStruct.UpdateFrequency == "" { + videoSourceStruct.UpdateFrequency = "@daily" + } + res, err := db.SQL.NamedExec(` INSERT INTO video_source (name, provider, username, password, base_url, m3u_url, max_streams, update_frequency) VALUES (:name, :provider, :username, :password, :base_url, :m3u_url, :max_streams, :update_frequency);`, videoSourceStruct) diff --git a/internal/models/video_source_track.go b/internal/models/video_source_track.go index 2e838de..739d76b 100644 --- a/internal/models/video_source_track.go +++ b/internal/models/video_source_track.go @@ -48,7 +48,7 @@ type VideoSourceTrack struct { type VideoSourceTrackAPI interface { InsertVideoSourceTrack(trackStruct VideoSourceTrack) (*VideoSourceTrack, error) DeleteVideoSourceTrack(trackID int) (*VideoSourceTrack, error) - UpdateVideoSourceTrack(trackID int, description string) (*VideoSourceTrack, error) + UpdateVideoSourceTrack(providerID, trackID int, trackStruct VideoSourceTrack) error GetVideoSourceTrackByID(id int, expanded bool) (*VideoSourceTrack, error) GetTracksForVideoSource(videoSourceID int) ([]VideoSourceTrack, error) } @@ -71,7 +71,7 @@ SELECT func (db *VideoSourceTrackDB) InsertVideoSourceTrack(trackStruct VideoSourceTrack) (*VideoSourceTrack, error) { track := VideoSourceTrack{} res, err := db.SQL.NamedExec(` - INSERT INTO video_source_track (video_source_id, name, stream_id, logo, type, category, epg_id) + INSERT OR REPLACE INTO video_source_track (video_source_id, name, stream_id, logo, type, category, epg_id) VALUES (:video_source_id, :name, :stream_id, :logo, :type, :category, :epg_id);`, trackStruct) if err != nil { return &track, err @@ -112,10 +112,9 @@ func (db *VideoSourceTrackDB) DeleteVideoSourceTrack(trackID int) (*VideoSourceT } // UpdateVideoSourceTrack updates a track. -func (db *VideoSourceTrackDB) UpdateVideoSourceTrack(trackID int, description string) (*VideoSourceTrack, error) { - track := VideoSourceTrack{} - err := db.SQL.Get(&track, `UPDATE video_source_track SET description = $2 WHERE id = $1 RETURNING *`, trackID, description) - return &track, err +func (db *VideoSourceTrackDB) UpdateVideoSourceTrack(providerID, streamID int, trackStruct VideoSourceTrack) error { + _, err := db.SQL.Exec(`UPDATE video_source_track SET category = ?, epg_id = ? WHERE video_source_id = ? AND stream_id = ?`, trackStruct.Category, trackStruct.EPGID, providerID, streamID) + return err } // GetTracksForVideoSource returns a slice of VideoSourceTracks for the given video source ID. diff --git a/migrations/20180913140221-AddVideoTrackUniqueConstraint.sql b/migrations/20180913140221-AddVideoTrackUniqueConstraint.sql new file mode 100644 index 0000000..ad17622 --- /dev/null +++ b/migrations/20180913140221-AddVideoTrackUniqueConstraint.sql @@ -0,0 +1,6 @@ + +-- +migrate Up + +CREATE UNIQUE INDEX track_unique ON video_source_track(video_source_id, stream_id); + +-- +migrate Down From 640f1493eb374d649a28b7131e6754214b6e6830 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 15 Sep 2018 17:38:19 -0700 Subject: [PATCH 169/182] Remove XMLTV parameter, it was never actually there, just a bad copy/paste. Replaced with GuideProviders.Channel --- internal/api/guide_source.go | 2 +- internal/models/guide_source_channel.go | 14 +++++++++----- 2 files changed, 10 insertions(+), 6 deletions(-) diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index f586b40..c9a1c3b 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -241,7 +241,7 @@ func match(guideSource *models.GuideSource, provider guideproviders.GuideProvide channelMap := make(map[string]models.GuideSourceChannel) for _, channel := range guideSource.Channels { - name := channel.XMLTV.DisplayNames[0].Value + name := channel.GuideProviderChannel.Name channels = append(channels, name) channelMap[name] = channel } diff --git a/internal/models/guide_source_channel.go b/internal/models/guide_source_channel.go index 5d090f7..5f086bd 100644 --- a/internal/models/guide_source_channel.go +++ b/internal/models/guide_source_channel.go @@ -7,7 +7,6 @@ import ( "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/guideproviders" - "github.com/tellytv/telly/internal/xmltv" squirrel "gopkg.in/Masterminds/squirrel.v1" ) @@ -41,9 +40,9 @@ type GuideSourceChannel struct { Data json.RawMessage `db:"data"` ImportedAt *time.Time `db:"imported_at"` - GuideSource *GuideSource - GuideSourceName string - XMLTV *xmltv.Channel `json:"-"` + GuideSource *GuideSource + GuideSourceName string + GuideProviderChannel *guideproviders.Channel `json:"-"` } // GuideSourceChannelAPI contains all methods for the User struct @@ -99,7 +98,7 @@ func (db *GuideSourceChannelDB) InsertGuideSourceChannel(guideID int, channel gu if getErr := db.SQL.Get(&outputChannel, "SELECT * FROM guide_source_channel WHERE id = $1", rowID); getErr != nil { return nil, getErr } - if unmarshalErr := json.Unmarshal(outputChannel.Data, &outputChannel.XMLTV); unmarshalErr != nil { + if unmarshalErr := json.Unmarshal(outputChannel.Data, &outputChannel.GuideProviderChannel); unmarshalErr != nil { return nil, unmarshalErr } return &outputChannel, err @@ -122,6 +121,11 @@ func (db *GuideSourceChannelDB) GetGuideSourceChannelByID(id int, expanded bool) return nil, guideErr } channel.GuideSource = guide + + if unmarshalErr := json.Unmarshal(channel.Data, &channel.GuideProviderChannel); unmarshalErr != nil { + return nil, unmarshalErr + } + } return &channel, err } From 4b3ada053b4eac727d0bab0feed2858150c014d0 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 15 Sep 2018 17:39:20 -0700 Subject: [PATCH 170/182] Fix the get programme queries to actually work --- internal/models/guide_source_programme.go | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/internal/models/guide_source_programme.go b/internal/models/guide_source_programme.go index c55598d..cd58717 100644 --- a/internal/models/guide_source_programme.go +++ b/internal/models/guide_source_programme.go @@ -142,7 +142,7 @@ func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID string, // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel))").OrderBy("start ASC").ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) AND start >= datetime('now') AND start <= datetime('now', '+12 hours')").OrderBy("start ASC").ToSql() if sqlGenErr != nil { return nil, sqlGenErr } @@ -162,14 +162,16 @@ func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourc // GetProgrammesForChannel returns a slice of GuideSourceProgrammes for the given XMLTV channel ID. func (db *GuideSourceProgrammeDB) GetProgrammesForChannel(channelID string) ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(squirrel.And{squirrel.Eq{"channel": channelID}, squirrel.GtOrEq{"start": "datetime('now')"}, squirrel.LtOrEq{"start": "datetime('now', '+6 hours')"}}).ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(fmt.Sprintf("channel = '%s' AND start >= datetime('now') AND start <= datetime('now', '+6 hours')", channelID)).ToSql() if sqlGenErr != nil { return nil, sqlGenErr } + err := db.SQL.Select(&programmes, sql, args...) if err != nil { return nil, err } + for idx, programme := range programmes { if unmarshalErr := json.Unmarshal(programme.Data, &programme.XMLTV); unmarshalErr != nil { return nil, unmarshalErr From a8b40cdd2c560269111a74da52ed61440c1466fd Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 15 Sep 2018 17:39:53 -0700 Subject: [PATCH 171/182] Fix log line --- internal/commands/video_updates.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/commands/video_updates.go b/internal/commands/video_updates.go index 5f98157..b43e138 100644 --- a/internal/commands/video_updates.go +++ b/internal/commands/video_updates.go @@ -19,7 +19,7 @@ func FireVideoUpdatesCommand() { } func fireVideoUpdates(cc *context.CContext, provider *models.VideoSource) error { - log.Debugf("Video source update is beginning for provider", provider.Name) + log.Debugln("Video source update is beginning for provider", provider.Name) channels, channelsErr := cc.VideoSourceProviders[provider.ID].Channels() if channelsErr != nil { From 25a449380108bdadcaf53c8ab03b12ea291aec06 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 15 Sep 2018 18:52:49 -0700 Subject: [PATCH 172/182] ensure lastStatusJSON isnt nil --- internal/guideproviders/schedules_direct.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index cdf4756..278e306 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -385,7 +385,7 @@ func (s *SchedulesDirect) Refresh(lastStatusJSON *json.RawMessage) ([]byte, erro lineupsMetadataMap := make(map[string]schedulesdirect.Lineup) var lastStatus schedulesdirect.StatusResponse - if len(*lastStatusJSON) > 0 { + if lastStatusJSON != nil && len(*lastStatusJSON) > 0 { if unmarshalErr := json.Unmarshal(*lastStatusJSON, &lastStatus); unmarshalErr != nil { return nil, fmt.Errorf("error unmarshalling cached status JSON: %s", unmarshalErr) } From d56d29269ca121a00d0cd2340b67be284a33f719 Mon Sep 17 00:00:00 2001 From: Robbie Trencheny Date: Sat, 15 Sep 2018 20:34:15 -0700 Subject: [PATCH 173/182] Fix programme query logic to return 7 days of data and anything with a start or end time of >= now --- internal/models/guide_source_programme.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/internal/models/guide_source_programme.go b/internal/models/guide_source_programme.go index cd58717..865a61c 100644 --- a/internal/models/guide_source_programme.go +++ b/internal/models/guide_source_programme.go @@ -142,7 +142,7 @@ func (db *GuideSourceProgrammeDB) UpdateGuideSourceProgramme(programmeID string, // GetProgrammesForActiveChannels returns a slice of GuideSourceProgrammes for actively assigned channels. func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) AND start >= datetime('now') AND start <= datetime('now', '+12 hours')").OrderBy("start ASC").ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where("channel IN (SELECT xmltv_id FROM guide_source_channel WHERE id IN (SELECT guide_channel_id FROM lineup_channel)) AND (start >= datetime('now') OR end >= datetime('now')) AND start <= datetime('now', '+7 days')").OrderBy("start ASC").ToSql() if sqlGenErr != nil { return nil, sqlGenErr } @@ -162,7 +162,7 @@ func (db *GuideSourceProgrammeDB) GetProgrammesForActiveChannels() ([]GuideSourc // GetProgrammesForChannel returns a slice of GuideSourceProgrammes for the given XMLTV channel ID. func (db *GuideSourceProgrammeDB) GetProgrammesForChannel(channelID string) ([]GuideSourceProgramme, error) { programmes := make([]GuideSourceProgramme, 0) - sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(fmt.Sprintf("channel = '%s' AND start >= datetime('now') AND start <= datetime('now', '+6 hours')", channelID)).ToSql() + sql, args, sqlGenErr := squirrel.Select("*").From("guide_source_programme").Where(fmt.Sprintf("channel = '%s' AND (start >= datetime('now') OR end >= datetime('now')) AND start <= datetime('now', '+7 days')", channelID)).ToSql() if sqlGenErr != nil { return nil, sqlGenErr } From cc3aeb7f933718e920c073b9ed32cb3295b230e1 Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Sun, 30 Sep 2018 18:47:05 -0500 Subject: [PATCH 174/182] Update README.md Trimmed stuff that doesn't apply to this branch to avoid confusion. --- README.md | 103 +++++------------------------------------------------- 1 file changed, 9 insertions(+), 94 deletions(-) diff --git a/README.md b/README.md index 30acec9..f42d381 100644 --- a/README.md +++ b/README.md @@ -2,88 +2,16 @@ IPTV proxy for Plex Live written in Golang -# Configuration - -Here's an example configuration file. **You will need to create this file.** It should be placed in `/etc/telly/telly.config.toml` or `$HOME/.telly/telly.config.toml` or `telly.config.toml` in the directory that telly is running from. - -```toml -[Discovery] # most likely you won't need to change anything here - Device-Auth = "telly123" # These settings are all related to how telly identifies - Device-ID = 12345678 # itself to Plex. - Device-UUID = "" - Device-Firmware-Name = "hdhomeruntc_atsc" - Device-Firmware-Version = "20150826" - Device-Friendly-Name = "telly" - Device-Manufacturer = "Silicondust" - Device-Model-Number = "HDTC-2US" - SSDP = true - -[IPTV] - Streams = 1 # number of simultaneous streams that the telly virtual DVR will be able to provide - # This is often 1, but is set by your iptv provider; for example, Vaders provides 5 - Starting-Channel = 10000 # When telly assigns channel numbers it will start here - XMLTV-Channels = true # if true, any channel numbers specified in your M3U file will be used. - FFMpeg = true # if true, streams are buffered through ffmpeg; ffmpeg must be on your $PATH - # if you want to use this with Docker, be sure you use the correct docker image - -[Log] - Level = "info" # Only log messages at or above the given level. [debug, info, warn, error, fatal] - Requests = true # Log HTTP requests made to telly - -[Web] - Base-Address = "0.0.0.0:6077" # Set this to the IP address of the machine telly runs on - Listen-Address = "0.0.0.0:6077" # this can stay as-is - -[SchedulesDirect] # If you have a Schedules Direct account, fill in details - Username = "" # This is under construction; Vader is the only provider - Password = "" # that works with it fully at this time - -[[Source]] - Name = "" # Name is optional and is used mostly for logging purposes - Provider = "Vaders" # named providers currently supported are "Vaders", "area51", "Iris" - Username = "" - Password = "" - Filter = "Sports|Premium Movies|United States.*|USA" - FilterKey = "tvg-name" # FilterKey normally defaults to whatever the provider file says is best, otherwise you must set this. - FilterRaw = false # FilterRaw will run your regex on the entire line instead of just specific keys. - Sort = "group-title" # Sort will alphabetically sort your channels by the M3U key provided - -[[Source]] - Name = "" - Provider = "IPTV-EPG" - Username = "M3U-Identifier" # From http://iptv-epg.com/[M3U-Identifier].m3u - Password = "XML-Identifier" # From http://iptv-epg.com/[XML-Identifier].xml - - -[[Source]] - Provider = "Custom" - M3U = "http://myprovider.com/playlist.m3u" - EPG = "http://myprovider.com/epg.xml" -``` -You only need one source; the ones you are not using should be commented out or deleted. The name and filter-related keys can be used with any of the sources. - -If you do not have a Schedules Direct account, that section can be removed or left blank. +## This is an ![#f92307](https://placehold.it/15/f92307/000000?text=+) unsupported branch ![#f92307](https://placehold.it/15/f92307/000000?text=+). It is under active development and prereleases based on it [1.5.x] should not be used by anyone who is intolerant of breakage. -Set listen- and base-address to the IP address of the machine running telly. - -# FFMpeg - -Telly can buffer the streams to Plex through ffmpeg. This has the potential for several benefits, but today it primarily: - -1. Allows support for stream formats that may cause problems for Plex directly. -1. Eliminates the use of redirects and makes it possible for telly to report exactly why a given stream failed. +# Configuration -To take advantage of this, ffmpeg must be installed and available in your path. +This branch uses a web ui for configuration and stored its configuration in a database. This UI and database are under development and subject to change without notice. # Docker -There are two different docker images available: - -## tellytv/telly:dev -The standard docker image for the dev branch - -## tellytv/telly:dev-ffmpeg -This docker image has ffmpeg preinstalled. If you want to use the ffmpeg feature, use this image. It may be safest to use this image generally, since it is not much larger than the standard image and allows you to turn the ffmpeg deatures on and off without requiring changes to your docker run command. The examples below use this image. +## tellytv/telly:v1.5.0 +The standard docker image for this branch ## `docker run` ``` @@ -91,30 +19,17 @@ docker run -d \ --name='telly' \ --net='bridge' \ -e TZ="America/Chicago" \ - -p '6077:6077/tcp' \ - -v /host/path/to/telly.config.toml:/etc/telly/telly.config.toml \ + -v ${PWD}/appdata:/etc/telly \ --restart unless-stopped \ - tellytv/telly:dev-ffmpeg -``` - -## docker-compose -``` -telly: - image: tellytv/telly:dev-ffmpeg - ports: - - "6077:6077" - environment: - - TZ=Europe/Amsterdam - volumes: - - /host/path/to/telly.config.toml:/etc/telly/telly.config.toml - restart: unless-stopped + tellytv/telly:v1.5.0 --database.file=/etc/telly/telly.db ``` # Troubleshooting Please free to open an issue if you run into any problems at all, we'll be more than happy to help. +## This is an ![#0eaf29](https://placehold.it/15/0eaf29/000000?text=+) unsupported branch ![#0eaf29](https://placehold.it/15/0eaf29/000000?text=+). It is under active development and prereleases based on it [1.5.x] should not be used by anyone who is intolerant of breakage. + # Social We have [a Discord server you can join!](https://discord.gg/bnNC8qX) - From b205a5e0c6b66e66084db4a9b8992f4aefbef499 Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Sun, 30 Sep 2018 18:48:04 -0500 Subject: [PATCH 175/182] Update README.md Too many "unsupported" warnings. --- README.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/README.md b/README.md index f42d381..64f321c 100644 --- a/README.md +++ b/README.md @@ -28,8 +28,6 @@ docker run -d \ Please free to open an issue if you run into any problems at all, we'll be more than happy to help. -## This is an ![#0eaf29](https://placehold.it/15/0eaf29/000000?text=+) unsupported branch ![#0eaf29](https://placehold.it/15/0eaf29/000000?text=+). It is under active development and prereleases based on it [1.5.x] should not be used by anyone who is intolerant of breakage. - # Social We have [a Discord server you can join!](https://discord.gg/bnNC8qX) From fc5afc267efb24df61093553ca2e28b503ffb1c5 Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Mon, 21 Jan 2019 17:54:36 -0600 Subject: [PATCH 176/182] Minor updates Update dependencies Allow M3U stream URLs to have no extension --- Gopkg.lock | 249 +++++++++++++++++++++----------- internal/videoproviders/main.go | 2 +- 2 files changed, 164 insertions(+), 87 deletions(-) diff --git a/Gopkg.lock b/Gopkg.lock index f277ff4..3e53ce1 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -3,17 +3,11 @@ [[projects]] branch = "master" - digest = "1:2c68a4843f0c805c1f69225bee2c8effb7be91437aa427a0155383e9d551f486" + digest = "1:13756ea2c4a6d979b8e1527238ec1cbcedcc8328501b8467e0b397ad97c262bc" name = "github.com/NebulousLabs/go-upnp" - packages = [ - "goupnp", - "goupnp/httpu", - "goupnp/scpd", - "goupnp/soap", - "goupnp/ssdp", - ] + packages = ["goupnp"] pruneopts = "UT" - revision = "29b680b06c82d044ebea91bf3069038eb562df2a" + revision = "b32978b8ccbffe222d6f37a980e795074ac2ba74" [[projects]] branch = "master" @@ -61,20 +55,36 @@ version = "v1.3.0" [[projects]] - digest = "1:f45caa3c5c4541c3a73b9fa2b38db97fcbda57618eaaaf45dd5c728362ad8f09" + digest = "1:4868df29afe0468bd98f663aff34f486b2e92db41f25747d8e6855c9cd91808b" + name = "github.com/gobuffalo/envy" + packages = ["."] + pruneopts = "UT" + revision = "f3b98d4da2fa434517f47f615e217fa72ff2c51e" + version = "v1.6.12" + +[[projects]] + branch = "master" + digest = "1:3617620c7cbc54dc84ab1f674ca021c1a9f49eeaa98ff81ceb202a626c7b9c66" + name = "github.com/gobuffalo/packd" + packages = ["."] + pruneopts = "UT" + revision = "eca3b8fd66872a76119b189bbe0f58f776a2a39f" + +[[projects]] + digest = "1:47c913f1b6469759fd0e8c6822d638346d170de20422bf5db3de842486756e32" name = "github.com/gobuffalo/packr" packages = ["."] pruneopts = "UT" - revision = "6c8156ee36301dd007342e79d81c99e7a7834337" - version = "v1.13.5" + revision = "679459352e18b4c74274a979d695fe13b68730c1" + version = "v1.21.9" [[projects]] - digest = "1:bbadccf3d3317ea03c0dac0b45b673b4b397c8f91a1d2eff550a3c51c4ad770e" - name = "github.com/gogo/protobuf" - packages = ["proto"] + branch = "master" + digest = "1:da425896866b704cec05178819d7f31c7d5dad4d705403607b971b326bc7fea3" + name = "github.com/gobuffalo/syncx" + packages = ["."] pruneopts = "UT" - revision = "636bf0302bc95575d69441b25a2603156ffdddf1" - version = "v1.1.1" + revision = "558ac7de985fc4f4057bff27c7bdf99e92fe0750" [[projects]] digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d" @@ -105,22 +115,38 @@ [[projects]] branch = "master" - digest = "1:7654989089e5bd5b6734ec3be8b695e87d3f1f8d95620b343fd7d3995a5b60d7" + digest = "1:d8715388cdd077d4b5e477e92e93e8c2c16c5f8cdc1f79b0ef2616ef8ea09f9f" name = "github.com/jmoiron/sqlx" packages = [ ".", "reflectx", ] pruneopts = "UT" - revision = "0dae4fefe7c0e190f7b5a78dac28a1c82cc8d849" + revision = "82935fac6c1a317907c8f43ed3f7f85ea844a78b" [[projects]] - digest = "1:be97e109f627d3ba8edfef50c9c74f0d0c17cbe3a2e924a8985e4804a894f282" + digest = "1:ecd9aa82687cf31d1585d4ac61d0ba180e42e8a6182b85bd785fcca8dfeefc1b" + name = "github.com/joho/godotenv" + packages = ["."] + pruneopts = "UT" + revision = "23d116af351c84513e1946b527c88823e476be13" + version = "v1.3.0" + +[[projects]] + digest = "1:3e551bbb3a7c0ab2a2bf4660e7fcad16db089fdcfbb44b0199e62838038623ea" name = "github.com/json-iterator/go" packages = ["."] pruneopts = "UT" - revision = "36b14963da70d11297d313183d7e6388c8510e1e" - version = "1.0.0" + revision = "1624edc4454b8682399def8740d46db5e4362ba4" + version = "v1.1.5" + +[[projects]] + digest = "1:0a69a1c0db3591fcefb47f115b224592c8dfa4368b7ba9fae509d5e16cdc95c8" + name = "github.com/konsorten/go-windows-terminal-sequences" + packages = ["."] + pruneopts = "UT" + revision = "5c8c8bd35d3832f5d134ae1e1e375b69a4d25242" + version = "v1.0.1" [[projects]] branch = "master" @@ -171,19 +197,28 @@ version = "v1.8.0" [[projects]] - digest = "1:fa610f9fe6a93f4a75e64c83673dfff9bf1a34bbb21e6102021b6bc7850834a3" + branch = "master" + digest = "1:6e2ed1bdbf1d14b4d0be58bcd3f1c3000c1e226964354457b8e6ca69e83a1cbb" + name = "github.com/markbates/oncer" + packages = ["."] + pruneopts = "UT" + revision = "bf2de49a0be218916e69a11d22866e6cd0a560f2" + +[[projects]] + digest = "1:0981502f9816113c9c8c4ac301583841855c8cf4da8c72f696b3ebedf6d0e4e5" name = "github.com/mattn/go-isatty" packages = ["."] pruneopts = "UT" - revision = "57fdcb988a5c543893cc61bce354a6e24ab70022" + revision = "6ca4dbf54d38eea1a992b3c722a76a5d1c4cb25c" + version = "v0.0.4" [[projects]] - digest = "1:3cafc6a5a1b8269605d9df4c6956d43d8011fc57f266ca6b9d04da6c09dee548" + digest = "1:4a49346ca45376a2bba679ca0e83bec949d780d4e927931317904bad482943ec" name = "github.com/mattn/go-sqlite3" packages = ["."] pruneopts = "UT" - revision = "25ecb14adfc7543176f7d85291ec7dba82c6f7e4" - version = "v1.9.0" + revision = "c7c4067b79cc51e6dfdcef5c702e74b1e0fa7c75" + version = "v1.10.0" [[projects]] digest = "1:ff5ebae34cfbf047d505ee150de27e60570e8c394b3b8fdbb720ff6ac71985fc" @@ -194,12 +229,28 @@ version = "v1.0.1" [[projects]] - digest = "1:645110e089152bd0f4a011a2648fbb0e4df5977be73ca605781157ac297f50c4" + digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318" name = "github.com/mitchellh/mapstructure" packages = ["."] pruneopts = "UT" - revision = "fa473d140ef3c6adf42d6b391fe76707f1f243c8" - version = "v1.0.0" + revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe" + version = "v1.1.2" + +[[projects]] + digest = "1:33422d238f147d247752996a26574ac48dcf472976eda7f5134015f06bf16563" + name = "github.com/modern-go/concurrent" + packages = ["."] + pruneopts = "UT" + revision = "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94" + version = "1.0.3" + +[[projects]] + digest = "1:e32bdbdb7c377a07a9a46378290059822efdce5c8d96fe71940d87cb4f918855" + name = "github.com/modern-go/reflect2" + packages = ["."] + pruneopts = "UT" + revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd" + version = "1.0.1" [[projects]] digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e" @@ -210,16 +261,16 @@ version = "v1.2.0" [[projects]] - digest = "1:40e195917a951a8bf867cd05de2a46aaf1806c50cf92eebf4c16f78cd196f747" + digest = "1:cf31692c14422fa27c83a05292eb5cbe0fb2775972e8f1f8446a71549bd8980b" name = "github.com/pkg/errors" packages = ["."] pruneopts = "UT" - revision = "645ef00459ed84a119197bfb8d8205042c6df63d" - version = "v0.8.0" + revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4" + version = "v0.8.1" [[projects]] branch = "master" - digest = "1:85e2aede1e81915ef1d12551ea082ce6aab0e0cfb70f7b29581ef496e1b0ec0d" + digest = "1:2cd09e6a31595e87e9fab1848e58202b161c595d6fdb1c4ed760f58f08f4bd86" name = "github.com/prometheus/client_golang" packages = [ "prometheus", @@ -227,7 +278,7 @@ "prometheus/promhttp", ] pruneopts = "UT" - revision = "3525612fea19680dd3d49c768802ec082ca853b2" + revision = "26e258bb9c9a94c26d4a46ff302ec7e855b82e10" [[projects]] branch = "master" @@ -235,11 +286,11 @@ name = "github.com/prometheus/client_model" packages = ["go"] pruneopts = "UT" - revision = "5c3871d89910bfb32f5fcab2aa4b9ec68e65a99f" + revision = "56726106282f1985ea77d5305743db7231b0c0a8" [[projects]] branch = "master" - digest = "1:9b2b68310a7555601c28980840f4d6966f8ff5443e11f4f78d227dbf73205132" + digest = "1:ab596fd5f3bc91cb112310ad80cf4b08c894d134652875fc7ca7d8621996f700" name = "github.com/prometheus/common" packages = [ "expfmt", @@ -248,11 +299,11 @@ "version", ] pruneopts = "UT" - revision = "c7de2306084e37d54b8be01f3541a8464345e9a5" + revision = "2998b132700a7d019ff618c06a234b47c1f3f681" [[projects]] branch = "master" - digest = "1:8c49953a1414305f2ff5465147ee576dd705487c35b15918fcd4efdc0cb7a290" + digest = "1:f532f2cdb9e9e4a8fad5a7e944482f4dd12650228e4a7a6c8492a0d069ce0690" name = "github.com/prometheus/procfs" packages = [ ".", @@ -261,7 +312,7 @@ "xfs", ] pruneopts = "UT" - revision = "05ee40e3a273f7245e8777337fc7b46e533a9a92" + revision = "bf6a532e95b1f7a62adf0ab5050a5bb2237ad2f4" [[projects]] digest = "1:ed615c5430ecabbb0fb7629a182da65ecee6523900ac1ac932520860878ffcad" @@ -271,24 +322,36 @@ revision = "b41be1df696709bb6395fe435af20370037c0b4c" version = "v1.1" +[[projects]] + digest = "1:e09ada96a5a41deda4748b1659cc8953961799e798aea557257b56baee4ecaf3" + name = "github.com/rogpeppe/go-internal" + packages = [ + "modfile", + "module", + "semver", + ] + pruneopts = "UT" + revision = "68d1cb014f030acd0f10ac553801e43c0e5da629" + version = "v1.1.0" + [[projects]] branch = "master" - digest = "1:cd638908d04442c8b6afd5d0221c21556e76c5e7130448ca97d249b47d66dd41" + digest = "1:adddeca6a627f69b0c34971dfc13292f334352d43ba0b9b121434ff92a2d04c1" name = "github.com/rubenv/sql-migrate" packages = [ ".", "sqlparse", ] pruneopts = "UT" - revision = "3f452fc0ebebbb784fdab91f7bc79a31dcacab5c" + revision = "5a8808c14925f69d2228981db113f672ad047e69" [[projects]] branch = "master" - digest = "1:ff6b0586c0621a76832cf783eee58cbb9d9795d2ce8acbc199a4131db11c42a9" + digest = "1:a3b8912deeef29007fab9a13a9f21b9e9b59c621a2ed61e2fe7b37320a71fbd5" name = "github.com/satori/go.uuid" packages = ["."] pruneopts = "UT" - revision = "36e9d2ebbde5e3f13ab2e25625fd453271d6522e" + revision = "b2ce2384e17bbe0c6d34077efa39dbab3e09123b" [[projects]] digest = "1:2b97fd8c3ebafa161b3cf34948a0dd7d1ec27ab3fed686eb3639ead64344e9e6" @@ -299,55 +362,55 @@ version = "v2.1.0" [[projects]] - digest = "1:d867dfa6751c8d7a435821ad3b736310c2ed68945d05b50fb9d23aee0540c8cc" + digest = "1:87c2e02fb01c27060ccc5ba7c5a407cc91147726f8f40b70cceeedbc52b1f3a8" name = "github.com/sirupsen/logrus" packages = ["."] pruneopts = "UT" - revision = "3e01752db0189b9157070a0e1668a620f9a85da2" - version = "v1.0.6" + revision = "e1e72e9de974bd926e5c56f83753fba2df402ce5" + version = "v1.3.0" [[projects]] - digest = "1:bd1ae00087d17c5a748660b8e89e1043e1e5479d0fea743352cda2f8dd8c4f84" + digest = "1:d707dbc1330c0ed177d4642d6ae102d5e2c847ebd0eb84562d0dc4f024531cfc" name = "github.com/spf13/afero" packages = [ ".", "mem", ] pruneopts = "UT" - revision = "787d034dfe70e44075ccc060d346146ef53270ad" - version = "v1.1.1" + revision = "a5d6946387efe7d64d09dcba68cdd523dc1273a3" + version = "v1.2.0" [[projects]] - digest = "1:516e71bed754268937f57d4ecb190e01958452336fa73dbac880894164e91c1f" + digest = "1:08d65904057412fc0270fc4812a1c90c594186819243160dc779a402d4b6d0bc" name = "github.com/spf13/cast" packages = ["."] pruneopts = "UT" - revision = "8965335b8c7107321228e3e3702cab9832751bac" - version = "v1.2.0" + revision = "8c9545af88b134710ab1cd196795e7f2388358d7" + version = "v1.3.0" [[projects]] - branch = "master" - digest = "1:8a020f916b23ff574845789daee6818daf8d25a4852419aae3f0b12378ba432a" + digest = "1:68ea4e23713989dc20b1bded5d9da2c5f9be14ff9885beef481848edd18c26cb" name = "github.com/spf13/jwalterweatherman" packages = ["."] pruneopts = "UT" - revision = "14d3d4c518341bea657dd8a226f5121c0ff8c9f2" + revision = "4a4406e478ca629068e7768fc33f3f044173c0a6" + version = "v1.0.0" [[projects]] - digest = "1:dab83a1bbc7ad3d7a6ba1a1cc1760f25ac38cdf7d96a5cdd55cd915a4f5ceaf9" + digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2" name = "github.com/spf13/pflag" packages = ["."] pruneopts = "UT" - revision = "9a97c102cda95a86cec2345a6f09f55a939babf5" - version = "v1.0.2" + revision = "298182f68c66c05229eb03ac171abe6e309ee79a" + version = "v1.0.3" [[projects]] - digest = "1:4fc8a61287ccfb4286e1ca5ad2ce3b0b301d746053bf44ac38cf34e40ae10372" + digest = "1:de37e343c64582d7026bf8ab6ac5b22a72eac54f3a57020db31524affed9f423" name = "github.com/spf13/viper" packages = ["."] pruneopts = "UT" - revision = "907c19d40d9a6c9bb55f040ff4ae45271a4754b9" - version = "v1.1.0" + revision = "6d33b5a963d922d182c91e8a1c88d81fd150cfd4" + version = "v1.3.1" [[projects]] branch = "master" @@ -359,38 +422,52 @@ [[projects]] branch = "master" - digest = "1:03cf379b75fbd215a1b0259db2b4ed517f0741f5bcac6a7c17c8c75acd97d71d" + digest = "1:fcab17d8743035b10ddec959fe3b92ac7f5f03c167570c70b50cdd8be9a9895a" name = "github.com/tellytv/go.xtream-codes" packages = ["."] pruneopts = "UT" - revision = "c42c5900a05a107a25b8d22970223f515532bee7" + revision = "9b74dcb500e4de481a064e5130909dee6ecabc1d" [[projects]] - digest = "1:c268acaa4a4d94a467980e5e91452eb61c460145765293dc0aed48e5e9919cc6" + digest = "1:03aa6e485e528acb119fb32901cf99582c380225fc7d5a02758e08b180cb56c3" name = "github.com/ugorji/go" packages = ["codec"] pruneopts = "UT" - revision = "c88ee250d0221a57af388746f5cf03768c21d6e2" + revision = "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab" + version = "v1.1.1" [[projects]] branch = "master" - digest = "1:6b5a4150d244cc9966fcf654c8354c96827786bb5b59cc09604cd0c566e35b02" + digest = "1:bcc3e8b281f79d903661fe821e5271e3732bfed74e7bb61f489f23321e664234" name = "github.com/zsais/go-gin-prometheus" packages = ["."] pruneopts = "UT" - revision = "f09dfa9cedec6f3e4ed39e49cceeda09cbed464f" + revision = "58963fb32f547bd98cc0150a6bcbdf181a430967" [[projects]] branch = "master" - digest = "1:3f3a05ae0b95893d90b9b3b5afdb79a9b3d96e4e36e099d841ae602e4aca0da8" + digest = "1:2b2911aa2860dec714c3957b5cc9ef20a4a1110c0dbf9dc0749ca5dd746bf381" + name = "gitlab.com/NebulousLabs/go-upnp" + packages = [ + "goupnp/httpu", + "goupnp/scpd", + "goupnp/soap", + "goupnp/ssdp", + ] + pruneopts = "UT" + revision = "3a71999ed0d393fba27f9c9b54f25a0943af97af" + +[[projects]] + branch = "master" + digest = "1:38f553aff0273ad6f367cb0a0f8b6eecbaef8dc6cb8b50e57b6a81c1d5b1e332" name = "golang.org/x/crypto" packages = ["ssh/terminal"] pruneopts = "UT" - revision = "0709b304e793a5edb4a2c0145f281ecdc20838a4" + revision = "ff983b9c42bc9fbf91556e191cc8efb585c16908" [[projects]] branch = "master" - digest = "1:5da7f8d7b8c0e04d5edc9f8a68b6199bc162ba379ac0ad6d3983a6f4c8125587" + digest = "1:c7d0da61b78fda6f5b43fb866488577ab90d4d6f5a453fb8318f5f213df64d90" name = "golang.org/x/net" packages = [ "bpf", @@ -402,18 +479,18 @@ "ipv4", ] pruneopts = "UT" - revision = "8a410e7b638dca158bf9e766925842f6651ff828" + revision = "ed066c81e75eba56dd9bd2139ade88125b855585" [[projects]] branch = "master" - digest = "1:7f4a61b989d94774dc61016b660cf8347f59eb0bed91a10b2f23fc72a38d45d4" + digest = "1:72f402ba458cb14ed7964c8b9a38d992f27834b3cf3479f3b08ea9e5334811b3" name = "golang.org/x/sys" packages = [ "unix", "windows", ] pruneopts = "UT" - revision = "ebe1bf3edb3325c393447059974de898d5133eb8" + revision = "770c60269bf0ef965e9e7ac8bedcb6bca2a1cefd" [[projects]] digest = "1:4392fcf42d5cf0e3ff78c96b2acf8223d49e4fdc53eb77c99d2f8dfe4680e006" @@ -445,36 +522,36 @@ version = "v0.3.0" [[projects]] - digest = "1:3ca2109e48660e527509b433c4efb5b910e5b9010d5149a6f44137d47b7970ca" + digest = "1:14a90eb1290bd0aa42848afa9ee2c9ce247abdb63c2cf614331670119760962f" name = "gopkg.in/Masterminds/squirrel.v1" packages = ["."] pruneopts = "UT" - revision = "a6b93000bd219143c56c16e6cb1c4b91da3f224b" - version = "v1.0" + revision = "fa735ea14f09f8685fcf5e75db091feb5a410730" + version = "v1.1" [[projects]] - digest = "1:1b4724d3c8125f6044925f02b485b74bfec9905cbf579d95aafd1a6c8f8447d3" + digest = "1:cbc72c4c4886a918d6ab4b95e347ffe259846260f99ebdd8a198c2331cf2b2e9" name = "gopkg.in/go-playground/validator.v8" packages = ["."] pruneopts = "UT" - revision = "5f57d2222ad794d0dffb07e664ea05e2ee07d60c" - version = "v8.18.1" + revision = "5f1438d3fca68893a817e4a66806cea46a9e4ebf" + version = "v8.18.2" [[projects]] - digest = "1:fa9a7c0ef59217bd22f32eb7cc027894d73f340a5633258cc079dec025db6a7f" + digest = "1:1b36b0cb56126316f637ad55cfd5ed84c945fe45bd90e944666b4107a80a1da9" name = "gopkg.in/gorp.v1" packages = ["."] pruneopts = "UT" - revision = "c87af80f3cc5036b55b83d77171e156791085e2e" - version = "v1.7.1" + revision = "6a667da9c028871f98598d85413e3fc4c6daa52e" + version = "v1.7.2" [[projects]] - digest = "1:342378ac4dcb378a5448dd723f0784ae519383532f5e70ade24132c4c8693202" + digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96" name = "gopkg.in/yaml.v2" packages = ["."] pruneopts = "UT" - revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183" - version = "v2.2.1" + revision = "51d6538a90f86fe93ac480b35f37b2be17fef232" + version = "v2.2.2" [solve-meta] analyzer-name = "dep" diff --git a/internal/videoproviders/main.go b/internal/videoproviders/main.go index fe7e2c6..25a91ca 100644 --- a/internal/videoproviders/main.go +++ b/internal/videoproviders/main.go @@ -6,7 +6,7 @@ import ( "strings" ) -var streamNumberRegex = regexp.MustCompile(`/(\d+).(mp4|mkv|avi|ts|.*.m3u8)`).FindAllStringSubmatch +var streamNumberRegex = regexp.MustCompile(`/(\d+).(mp4|mkv|avi|ts|.*.m3u8|\z)`).FindAllStringSubmatch // var channelNumberRegex = regexp.MustCompile(`^[0-9]+[[:space:]]?$`).MatchString // var callSignRegex = regexp.MustCompile(`^[A-Z0-9]+$`).MatchString From aa9b4f7b40e99f7c1d636350c07b87a1c2533d6b Mon Sep 17 00:00:00 2001 From: Chaz Larson Date: Sun, 17 Feb 2019 10:41:30 -0600 Subject: [PATCH 177/182] Bump VERSION Changes to Dockerfile to be sure it uses the Linux executable [Those driven by failing Docker builds on my OS X host] Added some mostly convenience sections to the Makefile --- Dockerfile | 2 +- Makefile | 18 +++++++++++++++--- VERSION | 2 +- 3 files changed, 17 insertions(+), 5 deletions(-) diff --git a/Dockerfile b/Dockerfile index 3bf6080..5fcff69 100644 --- a/Dockerfile +++ b/Dockerfile @@ -2,7 +2,7 @@ FROM jrottenberg/ffmpeg:4.0-alpine RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev -COPY telly /bin/telly +COPY .build/linux-amd64/telly /bin/telly USER nobody EXPOSE 6077 diff --git a/Makefile b/Makefile index 97d7aaa..0e479af 100644 --- a/Makefile +++ b/Makefile @@ -41,16 +41,28 @@ vet: build: promu @echo ">> building binaries" - @$(PROMU) build --prefix $(PREFIX) + @$(PROMU) build -v --prefix $(PREFIX) + +crossbuild: promu + @echo ">> building binaries" + @$(PROMU) crossbuild -v tarball: promu @echo ">> building release tarball" - @$(PROMU) tarball --prefix $(PREFIX) $(BIN_DIR) + @$(PROMU) tarball $(BIN_DIR) + +tarballs: promu + @echo ">> building release tarball" + @$(PROMU) crossbuild tarballs -docker: +docker: crossbuild @echo ">> building docker image" @docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . +docker-150: + @echo ">> building docker image" + @docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):v1.5.0" . + docker-publish: @echo ">> publishing docker image" @docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" diff --git a/VERSION b/VERSION index bc80560..26ca594 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.5.0 +1.5.1 From e7b08c59506cb030f448c226a8113a47767180e5 Mon Sep 17 00:00:00 2001 From: Matt Stevens Date: Thu, 6 Jun 2019 18:41:23 +0100 Subject: [PATCH 178/182] database-and-api merge latest dev changes and misc fixes (#252) * Add note that M3U can be a file path. * Fix some spelling * Update README.md * Update README.md * Note about pre-release status. * Update README.md * Clarify which sections are required * Update README.md * Update README.md * Update routes.go Remove the "-bsf:v", "h264_mp4toannexb" to fix HEVC streams. * Update to address minor bug in ffmpeg key handling * Typo * Minor fixes for breaking changes in go.schedulesdirect * More fixes for SD * Spelling fixes * Update README.md Specifically state not to change the magic provider names. * Note on key fields for multiple instances * Update .circleci/config.yml to use dep so that we stop having build breakage * Note about IPTV-EPG field names They don't make sense, but cest la vie. * Update README.md * Update README.md * Fix XMLTV date parsing because Vaders doesnt know how to write dates properly * Update README.md Add a reference to specific version. * Update Vaders URL * Update README.md * bump version to 1.1.0.5 * Add a log line in a situation that might indicate a missing config file. * Add a couple more targets * Build using the same mechanism as the makefile so the docker build has a version number Remove redundant build * Update README.md * Update tnt.go * hdhr device ids are alpha numeric * remove HDHomerun prefix from friendly name * Removed references to the late, lamented Vader Streams. * set content type for ffmpeg stream * remove unused ffmpeg option -tune is an encoding option. when passing -codec copy, no encoding is happening so that option is not used. since there is no encoding or decoding happening, it is incorrect to state that ffmpeg is transcoding. * replace dep with go mod * update dependencies * fix test failure * GOPATH not required anymore * fix version number configuration to be compatible with go modules * Bump version number to 1.1.0.6 * updated go.mod, go.sum * Use standard crossbuild for docker build instead of spinning up a docker build container. * Support multicast streams through udpxy in the custom provider (#238) * m3uplus parser: support UDP streams. * Allow customers using the custom provider to use udpxy as a multicast proxy. * fix squirrel imports to github.com source instead of gopkg.in gopkg was previously used to lock the version, this is now done correctly in Go 1.6 by cloning the Github default branch * replace satori/go.uuid with gofrs/uuid satori/go.uuid is no longer maintained * xmltv.go: restore a small linter that was rebased away * update go module deps --- .circleci/config.yml | 50 +- .gometalinter.json | 1 - .promu.yml | 10 +- Dockerfile | 14 +- Gopkg.lock | 585 ---------------------- Gopkg.toml | 122 ----- Makefile | 26 +- README.md | 2 +- go.mod | 49 ++ go.sum | 311 ++++++++++++ internal/api/tuner.go | 2 +- internal/m3uplus/main.go | 2 +- internal/models/guide_source.go | 2 +- internal/models/guide_source_channel.go | 2 +- internal/models/guide_source_programme.go | 2 +- internal/models/lineup.go | 4 +- internal/models/lineup_channel.go | 2 +- internal/models/main.go | 2 +- internal/models/video_source.go | 2 +- internal/models/video_source_track.go | 2 +- main.go | 20 + 21 files changed, 424 insertions(+), 788 deletions(-) delete mode 100644 Gopkg.lock delete mode 100644 Gopkg.toml create mode 100644 go.mod create mode 100644 go.sum diff --git a/.circleci/config.yml b/.circleci/config.yml index 0da2f31..bc83b7c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -34,52 +34,14 @@ jobs: docker_hub_master: docker: - - image: circleci/golang:1.10 - working_directory: /go/src/github.com/tellytv/telly + - image: circleci/golang:1 steps: - - checkout - - setup_remote_docker - - attach_workspace: - at: . - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - - run: ln -s .build/linux-amd64/telly telly - - run: make docker - - run: docker images - - run: docker login -u $DOCKER_LOGIN -p $DOCKER_PASSWORD - - run: make docker-publish - - docker_hub_release_tags: - docker: - - image: circleci/golang:1.10 - working_directory: /go/src/github.com/tellytv/telly - - steps: - - checkout - - setup_remote_docker - - run: mkdir -v -p ${HOME}/bin - - run: curl -L 'https://github.com/aktau/github-release/releases/download/v0.7.2/linux-amd64-github-release.tar.bz2' | tar xvjf - --strip-components 3 -C ${HOME}/bin - - run: echo 'export PATH=${HOME}/bin:${PATH}' >> ${BASH_ENV} - - attach_workspace: - at: . - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - - run: make promu - - run: make dep - - run: promu crossbuild tarballs - - run: promu checksum .tarballs - - run: promu release .tarballs - - store_artifacts: - path: .tarballs - destination: releases - - run: ln -s .build/linux-amd64/telly telly - - run: make docker DOCKER_IMAGE_TAG=$CIRCLE_TAG - - run: docker login -u $DOCKER_LOGIN -p $DOCKER_PASSWORD - # - run: | - # if [[ "$CIRCLE_TAG" =~ ^v[0-9]+(\.[0-9]+){2}$ ]]; then - # make docker-tag-latest DOCKER_IMAGE_TAG="$CIRCLE_TAG" - - # fi - - run: make docker-publish + - checkout + # - run: go get -u github.com/alecthomas/gometalinter + # - run: gometalinter --install + - run: go test -v ./... + # - run: gometalinter --config=.gometalinter.json ./... workflows: version: 2 diff --git a/.gometalinter.json b/.gometalinter.json index cbc79b6..6720d06 100644 --- a/.gometalinter.json +++ b/.gometalinter.json @@ -28,7 +28,6 @@ "Exclude": [ "^vendor\/", ".*-packr.go.*", - ".*squirrel.v1.*", ".*tableName is unused.*", "error return value not checked .*c.AbortWithError.*" ], diff --git a/.promu.yml b/.promu.yml index 0245391..2872458 100644 --- a/.promu.yml +++ b/.promu.yml @@ -5,11 +5,11 @@ go: build: flags: -a -tags 'netgo json1' ldflags: | - -X {{repoPath}}/vendor/github.com/prometheus/common/version.Version={{.Version}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.Revision={{.Revision}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.Branch={{.Branch}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildUser={{user}}@{{host}} - -X {{repoPath}}/vendor/github.com/prometheus/common/version.BuildDate={{date "20060102-15:04:05"}} + -X github.com/prometheus/common/version.Version={{.Version}} + -X github.com/prometheus/common/version.Revision={{.Revision}} + -X github.com/prometheus/common/version.Branch={{.Branch}} + -X github.com/prometheus/common/version.BuildUser={{user}}@{{host}} + -X github.com/prometheus/common/version.BuildDate={{date "20060102-15:04:05"}} tarball: files: - LICENSE diff --git a/Dockerfile b/Dockerfile index 5fcff69..7284ee9 100644 --- a/Dockerfile +++ b/Dockerfile @@ -1,12 +1,6 @@ -FROM jrottenberg/ffmpeg:4.0-alpine +FROM scratch +COPY .build/linux-amd64/telly ./app +EXPOSE 6077 +ENTRYPOINT ["./app"] -RUN apk update && apk upgrade && apk add --update --no-cache ca-certificates musl-dev -COPY .build/linux-amd64/telly /bin/telly - -USER nobody -EXPOSE 6077 -VOLUME [ "/telly" ] -WORKDIR /telly -ENTRYPOINT [ "/bin/telly" ] -CMD [ "--database.file=/telly/telly.db" ] diff --git a/Gopkg.lock b/Gopkg.lock deleted file mode 100644 index 3e53ce1..0000000 --- a/Gopkg.lock +++ /dev/null @@ -1,585 +0,0 @@ -# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'. - - -[[projects]] - branch = "master" - digest = "1:13756ea2c4a6d979b8e1527238ec1cbcedcc8328501b8467e0b397ad97c262bc" - name = "github.com/NebulousLabs/go-upnp" - packages = ["goupnp"] - pruneopts = "UT" - revision = "b32978b8ccbffe222d6f37a980e795074ac2ba74" - -[[projects]] - branch = "master" - digest = "1:d6afaeed1502aa28e80a4ed0981d570ad91b2579193404256ce672ed0a609e0d" - name = "github.com/beorn7/perks" - packages = ["quantile"] - pruneopts = "UT" - revision = "3a771d992973f24aa725d07868b467d1ddfceafb" - -[[projects]] - digest = "1:abeb38ade3f32a92943e5be54f55ed6d6e3b6602761d74b4aab4c9dd45c18abd" - name = "github.com/fsnotify/fsnotify" - packages = ["."] - pruneopts = "UT" - revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9" - version = "v1.4.7" - -[[projects]] - digest = "1:2b59aca2665ff804f6606c8829eaee133ddd3aefbc841014660d961b0034f888" - name = "github.com/gin-contrib/cors" - packages = ["."] - pruneopts = "UT" - revision = "cf4846e6a636a76237a28d9286f163c132e841bc" - version = "v1.2" - -[[projects]] - branch = "master" - digest = "1:36fe9527deed01d2a317617e59304eb2c4ce9f8a24115bcc5c2e37b3aee5bae4" - name = "github.com/gin-contrib/sse" - packages = ["."] - pruneopts = "UT" - revision = "22d885f9ecc78bf4ee5d72b937e4bbcdc58e8cae" - -[[projects]] - digest = "1:d5083934eb25e45d17f72ffa86cae3814f4a9d6c073c4f16b64147169b245606" - name = "github.com/gin-gonic/gin" - packages = [ - ".", - "binding", - "json", - "render", - ] - pruneopts = "UT" - revision = "b869fe1415e4b9eb52f247441830d502aece2d4d" - version = "v1.3.0" - -[[projects]] - digest = "1:4868df29afe0468bd98f663aff34f486b2e92db41f25747d8e6855c9cd91808b" - name = "github.com/gobuffalo/envy" - packages = ["."] - pruneopts = "UT" - revision = "f3b98d4da2fa434517f47f615e217fa72ff2c51e" - version = "v1.6.12" - -[[projects]] - branch = "master" - digest = "1:3617620c7cbc54dc84ab1f674ca021c1a9f49eeaa98ff81ceb202a626c7b9c66" - name = "github.com/gobuffalo/packd" - packages = ["."] - pruneopts = "UT" - revision = "eca3b8fd66872a76119b189bbe0f58f776a2a39f" - -[[projects]] - digest = "1:47c913f1b6469759fd0e8c6822d638346d170de20422bf5db3de842486756e32" - name = "github.com/gobuffalo/packr" - packages = ["."] - pruneopts = "UT" - revision = "679459352e18b4c74274a979d695fe13b68730c1" - version = "v1.21.9" - -[[projects]] - branch = "master" - digest = "1:da425896866b704cec05178819d7f31c7d5dad4d705403607b971b326bc7fea3" - name = "github.com/gobuffalo/syncx" - packages = ["."] - pruneopts = "UT" - revision = "558ac7de985fc4f4057bff27c7bdf99e92fe0750" - -[[projects]] - digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d" - name = "github.com/golang/protobuf" - packages = ["proto"] - pruneopts = "UT" - revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5" - version = "v1.2.0" - -[[projects]] - digest = "1:c0d19ab64b32ce9fe5cf4ddceba78d5bc9807f0016db6b1183599da3dcc24d10" - name = "github.com/hashicorp/hcl" - packages = [ - ".", - "hcl/ast", - "hcl/parser", - "hcl/printer", - "hcl/scanner", - "hcl/strconv", - "hcl/token", - "json/parser", - "json/scanner", - "json/token", - ] - pruneopts = "UT" - revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241" - version = "v1.0.0" - -[[projects]] - branch = "master" - digest = "1:d8715388cdd077d4b5e477e92e93e8c2c16c5f8cdc1f79b0ef2616ef8ea09f9f" - name = "github.com/jmoiron/sqlx" - packages = [ - ".", - "reflectx", - ] - pruneopts = "UT" - revision = "82935fac6c1a317907c8f43ed3f7f85ea844a78b" - -[[projects]] - digest = "1:ecd9aa82687cf31d1585d4ac61d0ba180e42e8a6182b85bd785fcca8dfeefc1b" - name = "github.com/joho/godotenv" - packages = ["."] - pruneopts = "UT" - revision = "23d116af351c84513e1946b527c88823e476be13" - version = "v1.3.0" - -[[projects]] - digest = "1:3e551bbb3a7c0ab2a2bf4660e7fcad16db089fdcfbb44b0199e62838038623ea" - name = "github.com/json-iterator/go" - packages = ["."] - pruneopts = "UT" - revision = "1624edc4454b8682399def8740d46db5e4362ba4" - version = "v1.1.5" - -[[projects]] - digest = "1:0a69a1c0db3591fcefb47f115b224592c8dfa4368b7ba9fae509d5e16cdc95c8" - name = "github.com/konsorten/go-windows-terminal-sequences" - packages = ["."] - pruneopts = "UT" - revision = "5c8c8bd35d3832f5d134ae1e1e375b69a4d25242" - version = "v1.0.1" - -[[projects]] - branch = "master" - digest = "1:8f57afa9ef1d9205094e9d89b9cb4ecb3123f342c4eb0053d7631181b511e6e4" - name = "github.com/koron/go-ssdp" - packages = ["."] - pruneopts = "UT" - revision = "4a0ed625a78b6858dc8d3a55fb7728968b712122" - -[[projects]] - digest = "1:ca955a9cd5b50b0f43d2cc3aeb35c951473eeca41b34eb67507f1dbcc0542394" - name = "github.com/kr/pretty" - packages = ["."] - pruneopts = "UT" - revision = "73f6ac0b30a98e433b289500d779f50c1a6f0712" - version = "v0.1.0" - -[[projects]] - digest = "1:15b5cc79aad436d47019f814fde81a10221c740dc8ddf769221a65097fb6c2e9" - name = "github.com/kr/text" - packages = ["."] - pruneopts = "UT" - revision = "e2ffdb16a802fe2bb95e2e35ff34f0e53aeef34f" - version = "v0.1.0" - -[[projects]] - branch = "master" - digest = "1:a7fc52742a5d011497b6a24024c857d260f809083424cd84110c9e40c34f64fc" - name = "github.com/lann/builder" - packages = ["."] - pruneopts = "UT" - revision = "47ae307949d02aa1f1069fdafc00ca08e1dbabac" - -[[projects]] - branch = "master" - digest = "1:225499d25a9f1486f3b77cdc4f7d6590c506c3839bb9d8497113f6d19676d54a" - name = "github.com/lann/ps" - packages = ["."] - pruneopts = "UT" - revision = "62de8c46ede02a7675c4c79c84883eb164cb71e3" - -[[projects]] - digest = "1:c568d7727aa262c32bdf8a3f7db83614f7af0ed661474b24588de635c20024c7" - name = "github.com/magiconair/properties" - packages = ["."] - pruneopts = "UT" - revision = "c2353362d570a7bfa228149c62842019201cfb71" - version = "v1.8.0" - -[[projects]] - branch = "master" - digest = "1:6e2ed1bdbf1d14b4d0be58bcd3f1c3000c1e226964354457b8e6ca69e83a1cbb" - name = "github.com/markbates/oncer" - packages = ["."] - pruneopts = "UT" - revision = "bf2de49a0be218916e69a11d22866e6cd0a560f2" - -[[projects]] - digest = "1:0981502f9816113c9c8c4ac301583841855c8cf4da8c72f696b3ebedf6d0e4e5" - name = "github.com/mattn/go-isatty" - packages = ["."] - pruneopts = "UT" - revision = "6ca4dbf54d38eea1a992b3c722a76a5d1c4cb25c" - version = "v0.0.4" - -[[projects]] - digest = "1:4a49346ca45376a2bba679ca0e83bec949d780d4e927931317904bad482943ec" - name = "github.com/mattn/go-sqlite3" - packages = ["."] - pruneopts = "UT" - revision = "c7c4067b79cc51e6dfdcef5c702e74b1e0fa7c75" - version = "v1.10.0" - -[[projects]] - digest = "1:ff5ebae34cfbf047d505ee150de27e60570e8c394b3b8fdbb720ff6ac71985fc" - name = "github.com/matttproud/golang_protobuf_extensions" - packages = ["pbutil"] - pruneopts = "UT" - revision = "c12348ce28de40eed0136aa2b644d0ee0650e56c" - version = "v1.0.1" - -[[projects]] - digest = "1:53bc4cd4914cd7cd52139990d5170d6dc99067ae31c56530621b18b35fc30318" - name = "github.com/mitchellh/mapstructure" - packages = ["."] - pruneopts = "UT" - revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe" - version = "v1.1.2" - -[[projects]] - digest = "1:33422d238f147d247752996a26574ac48dcf472976eda7f5134015f06bf16563" - name = "github.com/modern-go/concurrent" - packages = ["."] - pruneopts = "UT" - revision = "bacd9c7ef1dd9b15be4a9909b8ac7a4e313eec94" - version = "1.0.3" - -[[projects]] - digest = "1:e32bdbdb7c377a07a9a46378290059822efdce5c8d96fe71940d87cb4f918855" - name = "github.com/modern-go/reflect2" - packages = ["."] - pruneopts = "UT" - revision = "4b7aa43c6742a2c18fdef89dd197aaae7dac7ccd" - version = "1.0.1" - -[[projects]] - digest = "1:95741de3af260a92cc5c7f3f3061e85273f5a81b5db20d4bd68da74bd521675e" - name = "github.com/pelletier/go-toml" - packages = ["."] - pruneopts = "UT" - revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194" - version = "v1.2.0" - -[[projects]] - digest = "1:cf31692c14422fa27c83a05292eb5cbe0fb2775972e8f1f8446a71549bd8980b" - name = "github.com/pkg/errors" - packages = ["."] - pruneopts = "UT" - revision = "ba968bfe8b2f7e042a574c888954fccecfa385b4" - version = "v0.8.1" - -[[projects]] - branch = "master" - digest = "1:2cd09e6a31595e87e9fab1848e58202b161c595d6fdb1c4ed760f58f08f4bd86" - name = "github.com/prometheus/client_golang" - packages = [ - "prometheus", - "prometheus/internal", - "prometheus/promhttp", - ] - pruneopts = "UT" - revision = "26e258bb9c9a94c26d4a46ff302ec7e855b82e10" - -[[projects]] - branch = "master" - digest = "1:2d5cd61daa5565187e1d96bae64dbbc6080dacf741448e9629c64fd93203b0d4" - name = "github.com/prometheus/client_model" - packages = ["go"] - pruneopts = "UT" - revision = "56726106282f1985ea77d5305743db7231b0c0a8" - -[[projects]] - branch = "master" - digest = "1:ab596fd5f3bc91cb112310ad80cf4b08c894d134652875fc7ca7d8621996f700" - name = "github.com/prometheus/common" - packages = [ - "expfmt", - "internal/bitbucket.org/ww/goautoneg", - "model", - "version", - ] - pruneopts = "UT" - revision = "2998b132700a7d019ff618c06a234b47c1f3f681" - -[[projects]] - branch = "master" - digest = "1:f532f2cdb9e9e4a8fad5a7e944482f4dd12650228e4a7a6c8492a0d069ce0690" - name = "github.com/prometheus/procfs" - packages = [ - ".", - "internal/util", - "nfs", - "xfs", - ] - pruneopts = "UT" - revision = "bf6a532e95b1f7a62adf0ab5050a5bb2237ad2f4" - -[[projects]] - digest = "1:ed615c5430ecabbb0fb7629a182da65ecee6523900ac1ac932520860878ffcad" - name = "github.com/robfig/cron" - packages = ["."] - pruneopts = "UT" - revision = "b41be1df696709bb6395fe435af20370037c0b4c" - version = "v1.1" - -[[projects]] - digest = "1:e09ada96a5a41deda4748b1659cc8953961799e798aea557257b56baee4ecaf3" - name = "github.com/rogpeppe/go-internal" - packages = [ - "modfile", - "module", - "semver", - ] - pruneopts = "UT" - revision = "68d1cb014f030acd0f10ac553801e43c0e5da629" - version = "v1.1.0" - -[[projects]] - branch = "master" - digest = "1:adddeca6a627f69b0c34971dfc13292f334352d43ba0b9b121434ff92a2d04c1" - name = "github.com/rubenv/sql-migrate" - packages = [ - ".", - "sqlparse", - ] - pruneopts = "UT" - revision = "5a8808c14925f69d2228981db113f672ad047e69" - -[[projects]] - branch = "master" - digest = "1:a3b8912deeef29007fab9a13a9f21b9e9b59c621a2ed61e2fe7b37320a71fbd5" - name = "github.com/satori/go.uuid" - packages = ["."] - pruneopts = "UT" - revision = "b2ce2384e17bbe0c6d34077efa39dbab3e09123b" - -[[projects]] - digest = "1:2b97fd8c3ebafa161b3cf34948a0dd7d1ec27ab3fed686eb3639ead64344e9e6" - name = "github.com/schollz/closestmatch" - packages = ["."] - pruneopts = "UT" - revision = "56fb6b15a5e88fbcbc21b196488e749fc176514c" - version = "v2.1.0" - -[[projects]] - digest = "1:87c2e02fb01c27060ccc5ba7c5a407cc91147726f8f40b70cceeedbc52b1f3a8" - name = "github.com/sirupsen/logrus" - packages = ["."] - pruneopts = "UT" - revision = "e1e72e9de974bd926e5c56f83753fba2df402ce5" - version = "v1.3.0" - -[[projects]] - digest = "1:d707dbc1330c0ed177d4642d6ae102d5e2c847ebd0eb84562d0dc4f024531cfc" - name = "github.com/spf13/afero" - packages = [ - ".", - "mem", - ] - pruneopts = "UT" - revision = "a5d6946387efe7d64d09dcba68cdd523dc1273a3" - version = "v1.2.0" - -[[projects]] - digest = "1:08d65904057412fc0270fc4812a1c90c594186819243160dc779a402d4b6d0bc" - name = "github.com/spf13/cast" - packages = ["."] - pruneopts = "UT" - revision = "8c9545af88b134710ab1cd196795e7f2388358d7" - version = "v1.3.0" - -[[projects]] - digest = "1:68ea4e23713989dc20b1bded5d9da2c5f9be14ff9885beef481848edd18c26cb" - name = "github.com/spf13/jwalterweatherman" - packages = ["."] - pruneopts = "UT" - revision = "4a4406e478ca629068e7768fc33f3f044173c0a6" - version = "v1.0.0" - -[[projects]] - digest = "1:c1b1102241e7f645bc8e0c22ae352e8f0dc6484b6cb4d132fa9f24174e0119e2" - name = "github.com/spf13/pflag" - packages = ["."] - pruneopts = "UT" - revision = "298182f68c66c05229eb03ac171abe6e309ee79a" - version = "v1.0.3" - -[[projects]] - digest = "1:de37e343c64582d7026bf8ab6ac5b22a72eac54f3a57020db31524affed9f423" - name = "github.com/spf13/viper" - packages = ["."] - pruneopts = "UT" - revision = "6d33b5a963d922d182c91e8a1c88d81fd150cfd4" - version = "v1.3.1" - -[[projects]] - branch = "master" - digest = "1:56994293d84b7c01c28fc1479118038c238742ad24eeff676e11ffc45331e4e2" - name = "github.com/tellytv/go.schedulesdirect" - packages = ["."] - pruneopts = "UT" - revision = "bb2d9eec79e9ab9655574be4faa1e7b952478686" - -[[projects]] - branch = "master" - digest = "1:fcab17d8743035b10ddec959fe3b92ac7f5f03c167570c70b50cdd8be9a9895a" - name = "github.com/tellytv/go.xtream-codes" - packages = ["."] - pruneopts = "UT" - revision = "9b74dcb500e4de481a064e5130909dee6ecabc1d" - -[[projects]] - digest = "1:03aa6e485e528acb119fb32901cf99582c380225fc7d5a02758e08b180cb56c3" - name = "github.com/ugorji/go" - packages = ["codec"] - pruneopts = "UT" - revision = "b4c50a2b199d93b13dc15e78929cfb23bfdf21ab" - version = "v1.1.1" - -[[projects]] - branch = "master" - digest = "1:bcc3e8b281f79d903661fe821e5271e3732bfed74e7bb61f489f23321e664234" - name = "github.com/zsais/go-gin-prometheus" - packages = ["."] - pruneopts = "UT" - revision = "58963fb32f547bd98cc0150a6bcbdf181a430967" - -[[projects]] - branch = "master" - digest = "1:2b2911aa2860dec714c3957b5cc9ef20a4a1110c0dbf9dc0749ca5dd746bf381" - name = "gitlab.com/NebulousLabs/go-upnp" - packages = [ - "goupnp/httpu", - "goupnp/scpd", - "goupnp/soap", - "goupnp/ssdp", - ] - pruneopts = "UT" - revision = "3a71999ed0d393fba27f9c9b54f25a0943af97af" - -[[projects]] - branch = "master" - digest = "1:38f553aff0273ad6f367cb0a0f8b6eecbaef8dc6cb8b50e57b6a81c1d5b1e332" - name = "golang.org/x/crypto" - packages = ["ssh/terminal"] - pruneopts = "UT" - revision = "ff983b9c42bc9fbf91556e191cc8efb585c16908" - -[[projects]] - branch = "master" - digest = "1:c7d0da61b78fda6f5b43fb866488577ab90d4d6f5a453fb8318f5f213df64d90" - name = "golang.org/x/net" - packages = [ - "bpf", - "html", - "html/atom", - "html/charset", - "internal/iana", - "internal/socket", - "ipv4", - ] - pruneopts = "UT" - revision = "ed066c81e75eba56dd9bd2139ade88125b855585" - -[[projects]] - branch = "master" - digest = "1:72f402ba458cb14ed7964c8b9a38d992f27834b3cf3479f3b08ea9e5334811b3" - name = "golang.org/x/sys" - packages = [ - "unix", - "windows", - ] - pruneopts = "UT" - revision = "770c60269bf0ef965e9e7ac8bedcb6bca2a1cefd" - -[[projects]] - digest = "1:4392fcf42d5cf0e3ff78c96b2acf8223d49e4fdc53eb77c99d2f8dfe4680e006" - name = "golang.org/x/text" - packages = [ - "encoding", - "encoding/charmap", - "encoding/htmlindex", - "encoding/internal", - "encoding/internal/identifier", - "encoding/japanese", - "encoding/korean", - "encoding/simplifiedchinese", - "encoding/traditionalchinese", - "encoding/unicode", - "internal/gen", - "internal/tag", - "internal/triegen", - "internal/ucd", - "internal/utf8internal", - "language", - "runes", - "transform", - "unicode/cldr", - "unicode/norm", - ] - pruneopts = "UT" - revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0" - version = "v0.3.0" - -[[projects]] - digest = "1:14a90eb1290bd0aa42848afa9ee2c9ce247abdb63c2cf614331670119760962f" - name = "gopkg.in/Masterminds/squirrel.v1" - packages = ["."] - pruneopts = "UT" - revision = "fa735ea14f09f8685fcf5e75db091feb5a410730" - version = "v1.1" - -[[projects]] - digest = "1:cbc72c4c4886a918d6ab4b95e347ffe259846260f99ebdd8a198c2331cf2b2e9" - name = "gopkg.in/go-playground/validator.v8" - packages = ["."] - pruneopts = "UT" - revision = "5f1438d3fca68893a817e4a66806cea46a9e4ebf" - version = "v8.18.2" - -[[projects]] - digest = "1:1b36b0cb56126316f637ad55cfd5ed84c945fe45bd90e944666b4107a80a1da9" - name = "gopkg.in/gorp.v1" - packages = ["."] - pruneopts = "UT" - revision = "6a667da9c028871f98598d85413e3fc4c6daa52e" - version = "v1.7.2" - -[[projects]] - digest = "1:4d2e5a73dc1500038e504a8d78b986630e3626dc027bc030ba5c75da257cdb96" - name = "gopkg.in/yaml.v2" - packages = ["."] - pruneopts = "UT" - revision = "51d6538a90f86fe93ac480b35f37b2be17fef232" - version = "v2.2.2" - -[solve-meta] - analyzer-name = "dep" - analyzer-version = 1 - input-imports = [ - "github.com/NebulousLabs/go-upnp/goupnp", - "github.com/gin-contrib/cors", - "github.com/gin-gonic/gin", - "github.com/gobuffalo/packr", - "github.com/jmoiron/sqlx", - "github.com/koron/go-ssdp", - "github.com/kr/pretty", - "github.com/mattn/go-sqlite3", - "github.com/mitchellh/mapstructure", - "github.com/prometheus/client_golang/prometheus", - "github.com/prometheus/common/version", - "github.com/robfig/cron", - "github.com/rubenv/sql-migrate", - "github.com/satori/go.uuid", - "github.com/schollz/closestmatch", - "github.com/sirupsen/logrus", - "github.com/spf13/pflag", - "github.com/spf13/viper", - "github.com/tellytv/go.schedulesdirect", - "github.com/tellytv/go.xtream-codes", - "github.com/zsais/go-gin-prometheus", - "golang.org/x/net/html/charset", - "gopkg.in/Masterminds/squirrel.v1", - ] - solver-name = "gps-cdcl" - solver-version = 1 diff --git a/Gopkg.toml b/Gopkg.toml deleted file mode 100644 index 0b80034..0000000 --- a/Gopkg.toml +++ /dev/null @@ -1,122 +0,0 @@ -# Gopkg.toml example -# -# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html -# for detailed Gopkg.toml documentation. -# -# required = ["github.com/user/thing/cmd/thing"] -# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"] -# -# [[constraint]] -# name = "github.com/user/project" -# version = "1.0.0" -# -# [[constraint]] -# name = "github.com/user/project2" -# branch = "dev" -# source = "github.com/myfork/project2" -# -# [[override]] -# name = "github.com/x/y" -# version = "2.4.0" -# -# [prune] -# non-go = false -# go-tests = true -# unused-packages = true - - -[[constraint]] - branch = "master" - name = "github.com/NebulousLabs/go-upnp" - -[[constraint]] - name = "github.com/gin-contrib/cors" - version = "1.2.0" - -[[constraint]] - name = "github.com/gin-gonic/gin" - version = "1.3.0" - -[[constraint]] - name = "github.com/gobuffalo/packr" - version = "1.13.5" - -[[constraint]] - branch = "master" - name = "github.com/jmoiron/sqlx" - -[[constraint]] - name = "github.com/koron/go-ssdp" - branch = "master" - -[[constraint]] - name = "github.com/kr/pretty" - version = "0.1.0" - -[[constraint]] - name = "github.com/mattn/go-sqlite3" - version = "1.9.0" - -[[constraint]] - name = "github.com/mitchellh/mapstructure" - version = "1.0.0" - -[[constraint]] - name = "github.com/prometheus/client_golang" - branch = "master" - -[[constraint]] - branch = "master" - name = "github.com/prometheus/common" - -[[constraint]] - name = "github.com/robfig/cron" - version = "1.1.0" - -[[constraint]] - branch = "master" - name = "github.com/rubenv/sql-migrate" - -[[constraint]] - name = "github.com/satori/go.uuid" - branch = "master" - -[[constraint]] - name = "github.com/schollz/closestmatch" - version = "2.1.0" - -[[constraint]] - name = "github.com/sirupsen/logrus" - version = "1.0.6" - -[[constraint]] - name = "github.com/spf13/pflag" - version = "1.0.2" - -[[constraint]] - name = "github.com/spf13/viper" - version = "1.1.0" - -[[constraint]] - branch = "master" - name = "github.com/tellytv/go.schedulesdirect" - -[[constraint]] - branch = "master" - name = "github.com/tellytv/go.xtream-codes" - -[[constraint]] - branch = "master" - name = "github.com/zsais/go-gin-prometheus" - -[[constraint]] - branch = "master" - name = "golang.org/x/net" - -[[constraint]] - name = "gopkg.in/Masterminds/squirrel.v1" - version = "1.0" - -[prune] - go-tests = true - unused-packages = true diff --git a/Makefile b/Makefile index 0e479af..99c44df 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,6 @@ -# Ensure GOBIN is not set during build so that promu is installed to the correct path -unexport GOBIN +GO := go +GOPATH ?= $(HOME)/go +PROMU := $(GOPATH)/bin/promu GO ?= go GOFMT ?= $(GO)fmt @@ -33,12 +34,20 @@ test: format: @echo ">> formatting code" - @$(GOFMT) . + @$(GO) fmt ./... vet: @echo ">> vetting code" @$(GO) vet ./... +cross: promu + @echo ">> crossbuilding binaries" + @$(PROMU) crossbuild + +tarballs: promu + @echo ">> creating release tarballs" + @$(PROMU) crossbuild tarballs + build: promu @echo ">> building binaries" @$(PROMU) build -v --prefix $(PREFIX) @@ -51,11 +60,7 @@ tarball: promu @echo ">> building release tarball" @$(PROMU) tarball $(BIN_DIR) -tarballs: promu - @echo ">> building release tarball" - @$(PROMU) crossbuild tarballs - -docker: crossbuild +docker: cross @echo ">> building docker image" @docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . @@ -71,7 +76,10 @@ docker-tag-latest: @docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):latest" promu: - GOOS= GOARCH= $(GO) get -u github.com/prometheus/promu + @GO111MODULE=off \ + GOOS=$(shell uname -s | tr A-Z a-z) \ + GOARCH=$(subst x86_64,amd64,$(patsubst i%86,386,$(shell uname -m))) \ + $(GO) get -u github.com/prometheus/promu .PHONY: all style dep format build test vet tarball docker docker-publish docker-tag-latest promu diff --git a/README.md b/README.md index 64f321c..ef1e987 100644 --- a/README.md +++ b/README.md @@ -26,7 +26,7 @@ docker run -d \ # Troubleshooting -Please free to open an issue if you run into any problems at all, we'll be more than happy to help. +Please free to [open an issue](https://github.com/tellytv/telly/issues) if you run into any problems at all, we'll be more than happy to help. # Social diff --git a/go.mod b/go.mod new file mode 100644 index 0000000..18b825a --- /dev/null +++ b/go.mod @@ -0,0 +1,49 @@ +module github.com/tellytv/telly + +go 1.12 + +require ( + github.com/Masterminds/squirrel v1.1.0 + github.com/NebulousLabs/go-upnp v0.0.0-20181203152547-b32978b8ccbf + github.com/gin-contrib/cors v1.3.0 + github.com/gin-contrib/sse v0.1.0 // indirect + github.com/gin-gonic/gin v1.4.0 + github.com/go-sql-driver/mysql v1.4.1 // indirect + github.com/gobuffalo/packd v0.1.0 // indirect + github.com/gobuffalo/packr v1.25.0 + github.com/gofrs/uuid v3.2.0+incompatible + github.com/jmoiron/sqlx v1.2.0 + github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect + github.com/koron/go-ssdp v0.0.0-20180514024734-4a0ed625a78b + github.com/kr/pretty v0.1.0 + github.com/lib/pq v1.1.1 // indirect + github.com/magiconair/properties v1.8.1 // indirect + github.com/mattn/go-isatty v0.0.8 // indirect + github.com/mattn/go-sqlite3 v1.10.0 + github.com/mitchellh/mapstructure v1.1.2 + github.com/onsi/ginkgo v1.8.0 // indirect + github.com/onsi/gomega v1.5.0 // indirect + github.com/pelletier/go-toml v1.4.0 // indirect + github.com/prometheus/client_golang v0.9.3 + github.com/prometheus/common v0.4.1 + github.com/prometheus/procfs v0.0.2 // indirect + github.com/robfig/cron v1.1.0 + github.com/rubenv/sql-migrate v0.0.0-20190327083759-54bad0a9b051 + github.com/schollz/closestmatch v2.1.0+incompatible + github.com/sirupsen/logrus v1.4.2 + github.com/spf13/afero v1.2.2 // indirect + github.com/spf13/jwalterweatherman v1.1.0 // indirect + github.com/spf13/pflag v1.0.3 + github.com/spf13/viper v1.4.0 + github.com/tellytv/go.schedulesdirect v0.0.0-20180903021109-bb2d9eec79e9 + github.com/tellytv/go.xtream-codes v0.0.0-20190427212115-45e8162ba888 + github.com/ugorji/go v1.1.5-pre // indirect + github.com/ziutek/mymysql v1.5.4 // indirect + github.com/zsais/go-gin-prometheus v0.0.0-20181030200533-58963fb32f54 + gitlab.com/NebulousLabs/go-upnp v0.0.0-20181011194642-3a71999ed0d3 // indirect + golang.org/x/net v0.0.0-20190603091049-60506f45cf65 + golang.org/x/sys v0.0.0-20190606122018-79a91cf218c4 // indirect + golang.org/x/text v0.3.2 // indirect + google.golang.org/appengine v1.6.0 // indirect + gopkg.in/gorp.v1 v1.7.2 // indirect +) diff --git a/go.sum b/go.sum new file mode 100644 index 0000000..6a0be3c --- /dev/null +++ b/go.sum @@ -0,0 +1,311 @@ +cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw= +github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ= +github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= +github.com/Masterminds/squirrel v1.1.0 h1:baP1qLdoQCeTw3ifCdOq2dkYc6vGcmRdaociKLbEJXs= +github.com/Masterminds/squirrel v1.1.0/go.mod h1:yaPeOnPG5ZRwL9oKdTsO/prlkPbXWZlRVMQ/gGlzIuA= +github.com/NebulousLabs/go-upnp v0.0.0-20181203152547-b32978b8ccbf h1:1UP+tqdgLAKwt6NpefYq/SdyFaelU8MXOThESt6Od1U= +github.com/NebulousLabs/go-upnp v0.0.0-20181203152547-b32978b8ccbf/go.mod h1:GbuBk21JqF+driLX3XtJYNZjGa45YDoa9IqCTzNSfEc= +github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU= +github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc h1:cAKDfWh5VpdgMhJosfJnn5/FoN2SRZ4p7fJNX58YPaU= +github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc= +github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf h1:qet1QNfXsQxTZqLG4oE62mJzwPIB8+Tee4RNCL9ulrY= +github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0= +github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0= +github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= +github.com/beorn7/perks v1.0.0 h1:HWo1m869IqiPhD389kmkxeTalrjNbbJTC8LXupb+sl0= +github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8= +github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc= +github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw= +github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk= +github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE= +github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk= +github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4= +github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA= +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ= +github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no= +github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I= +github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo= +github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04= +github.com/gin-contrib/cors v1.3.0 h1:PolezCc89peu+NgkIWt9OB01Kbzt6IP0J/JvkG6xxlg= +github.com/gin-contrib/cors v1.3.0/go.mod h1:artPvLlhkF7oG06nK8v3U8TNz6IeX+w1uzCSEId5/Vc= +github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s= +github.com/gin-contrib/sse v0.1.0 h1:Y/yl/+YNO8GZSjAhjMsSuLt29uWRFHdHYUb5lYOV9qE= +github.com/gin-contrib/sse v0.1.0/go.mod h1:RHrZQHXnP2xjPF+u1gW/2HnVO7nvIa9PG3Gm+fLHvGI= +github.com/gin-gonic/gin v1.4.0 h1:3tMoCCfM7ppqsR0ptz/wi1impNpT7/9wQtMZ8lr1mCQ= +github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM= +github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as= +github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE= +github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk= +github.com/go-sql-driver/mysql v1.4.0 h1:7LxgVwFb2hIQtMm87NdgAVfXjnt4OePseqT1tKx+opk= +github.com/go-sql-driver/mysql v1.4.0/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= +github.com/go-sql-driver/mysql v1.4.1 h1:g24URVg0OFbNUTx9qqY1IRZ9D9z3iPyi5zKhQZpNwpA= +github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w= +github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY= +github.com/gobuffalo/attrs v0.0.0-20190224210810-a9411de4debd/go.mod h1:4duuawTqi2wkkpB4ePgWMaai6/Kc6WEz83bhFwpHzj0= +github.com/gobuffalo/depgen v0.0.0-20190329151759-d478694a28d3/go.mod h1:3STtPUQYuzV0gBVOY3vy6CfMm/ljR4pABfrTeHNLHUY= +github.com/gobuffalo/envy v1.6.15/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= +github.com/gobuffalo/envy v1.7.0 h1:GlXgaiBkmrYMHco6t4j7SacKO4XUjvh5pwXh0f4uxXU= +github.com/gobuffalo/envy v1.7.0/go.mod h1:n7DRkBerg/aorDM8kbduw5dN3oXGswK5liaSCx4T5NI= +github.com/gobuffalo/flect v0.1.0/go.mod h1:d2ehjJqGOH/Kjqcoz+F7jHTBbmDb38yXA598Hb50EGs= +github.com/gobuffalo/flect v0.1.1/go.mod h1:8JCgGVbRjJhVgD6399mQr4fx5rRfGKVzFjbj6RE/9UI= +github.com/gobuffalo/genny v0.0.0-20190329151137-27723ad26ef9/go.mod h1:rWs4Z12d1Zbf19rlsn0nurr75KqhYp52EAGGxTbBhNk= +github.com/gobuffalo/genny v0.0.0-20190403191548-3ca520ef0d9e/go.mod h1:80lIj3kVJWwOrXWWMRzzdhW3DsrdjILVil/SFKBzF28= +github.com/gobuffalo/gitgen v0.0.0-20190315122116-cc086187d211/go.mod h1:vEHJk/E9DmhejeLeNt7UVvlSGv3ziL+djtTr3yyzcOw= +github.com/gobuffalo/gogen v0.0.0-20190315121717-8f38393713f5/go.mod h1:V9QVDIxsgKNZs6L2IYiGR8datgMhB577vzTDqypH360= +github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2 h1:8thhT+kUJMTMy3HlX4+y9Da+BNJck+p109tqqKp7WDs= +github.com/gobuffalo/logger v0.0.0-20190315122211-86e12af44bc2/go.mod h1:QdxcLw541hSGtBnhUc4gaNIXRjiDppFGaDqzbrBd3v8= +github.com/gobuffalo/mapi v1.0.1/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= +github.com/gobuffalo/mapi v1.0.2 h1:fq9WcL1BYrm36SzK6+aAnZ8hcp+SrmnDyAxhNx8dvJk= +github.com/gobuffalo/mapi v1.0.2/go.mod h1:4VAGh89y6rVOvm5A8fKFxYG+wIW6LO1FMTG9hnKStFc= +github.com/gobuffalo/packd v0.0.0-20190315124812-a385830c7fc0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= +github.com/gobuffalo/packd v0.1.0 h1:4sGKOD8yaYJ+dek1FDkwcxCHA40M4kfKgFHx8N2kwbU= +github.com/gobuffalo/packd v0.1.0/go.mod h1:M2Juc+hhDXf/PnmBANFCqx4DM3wRbgDvnVWeG2RIxq4= +github.com/gobuffalo/packr v1.25.0 h1:NtPK45yOKFdTKHTvRGKL+UIKAKmJVWIVJOZBDI/qEdY= +github.com/gobuffalo/packr v1.25.0/go.mod h1:NqsGg8CSB2ZD+6RBIRs18G7aZqdYDlYNNvsSqP6T4/U= +github.com/gobuffalo/packr/v2 v2.0.9/go.mod h1:emmyGweYTm6Kdper+iywB6YK5YzuKchGtJQZ0Odn4pQ= +github.com/gobuffalo/packr/v2 v2.1.0/go.mod h1:n90ZuXIc2KN2vFAOQascnPItp9A2g9QYSvYvS3AjQEM= +github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754 h1:tpom+2CJmpzAWj5/VEHync2rJGi+epHNIeRSWjzGA+4= +github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY95UYwwW3uSASeV7vtgYkT2t16hJgV3AEPUpw= +github.com/gofrs/uuid v3.2.0+incompatible h1:y12jRkkFxsd7GpqdSZ+/KCs/fJbqpEXSGd4+jfEaewE= +github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= +github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= +github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= +github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= +github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A= +github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg= +github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U= +github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ= +github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M= +github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ= +github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs= +github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk= +github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY= +github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= +github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= +github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI= +github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= +github.com/jmoiron/sqlx v1.2.0 h1:41Ip0zITnmWNR/vHV+S4m+VoUivnWY5E4OJfLZjCJMA= +github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks= +github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc= +github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg= +github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo= +github.com/json-iterator/go v1.1.6 h1:MrUvLMLTMxbqFJ9kzlvat/rYZqZnW3u4wkLzWTaFwKs= +github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU= +github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= +github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4= +github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= +github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s= +github.com/konsorten/go-windows-terminal-sequences v1.0.2/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= +github.com/koron/go-ssdp v0.0.0-20180514024734-4a0ed625a78b h1:wxtKgYHEncAU00muMD06dzLiahtGM1eouRNOzVV7tdQ= +github.com/koron/go-ssdp v0.0.0-20180514024734-4a0ed625a78b/go.mod h1:5Ky9EC2xfoUKUor0Hjgi2BJhCSXJfMOFlmyYrVKGQMk= +github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc= +github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI= +github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo= +github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= +github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE= +github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= +github.com/lann/builder v0.0.0-20180802200727-47ae307949d0 h1:SOEGU9fKiNWd/HOJuq6+3iTQz8KNCLtVX6idSoTLdUw= +github.com/lann/builder v0.0.0-20180802200727-47ae307949d0/go.mod h1:dXGbAdH5GtBTC4WfIxhKZfyBF/HBFgRZSWwZ9g/He9o= +github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0 h1:P6pPBnrTSX3DEVR4fDembhRWSsG5rVo6hYhAB/ADZrk= +github.com/lann/ps v0.0.0-20150810152359-62de8c46ede0/go.mod h1:vmVJ0l/dxyfGW6FmdpVm2joNMFikkuWg0EoCKLGUMNw= +github.com/lib/pq v1.0.0 h1:X5PMW56eZitiTeO7tKzZxFCSpbFZJtkMMooicw2us9A= +github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= +github.com/lib/pq v1.1.1 h1:sJZmqHoEaY7f+NPP8pgLB/WxulyR3fewgCM2qaSlBb4= +github.com/lib/pq v1.1.1/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo= +github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY= +github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/magiconair/properties v1.8.1 h1:ZC2Vc7/ZFkGmsVC9KvOjumD+G5lXy2RtTKyzRKO2BQ4= +github.com/magiconair/properties v1.8.1/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ= +github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2 h1:JgVTCPf0uBVcUSWpyXmGpgOc62nK5HWUBKAGc3Qqa5k= +github.com/markbates/oncer v0.0.0-20181203154359-bf2de49a0be2/go.mod h1:Ld9puTsIW75CHf65OeIOkyKbteujpZVXDpWK6YGZbxE= +github.com/markbates/safe v1.0.1 h1:yjZkbvRM6IzKj9tlu/zMJLS0n/V351OZWRnF3QfaUxI= +github.com/markbates/safe v1.0.1/go.mod h1:nAqgmRi7cY2nqMc92/bSEeQA+R4OheNU2T1kNSCBdG0= +github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE= +github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= +github.com/mattn/go-sqlite3 v1.9.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/mattn/go-sqlite3 v1.10.0 h1:jbhqpg7tQe4SupckyijYiy0mJJ/pRyHvXf7JdWK860o= +github.com/mattn/go-sqlite3 v1.10.0/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= +github.com/matttproud/golang_protobuf_extensions v1.0.1 h1:4hp9jkHxhMHkqkrB3Ix0jegS5sx/RkqARlsWZ6pIwiU= +github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0= +github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE= +github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg= +github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q= +github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI= +github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0= +github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U= +github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U= +github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw= +github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/ginkgo v1.8.0 h1:VkHVNpR4iVnU8XQR6DBm8BqYjN7CRzw+xKUbVVbbW9w= +github.com/onsi/ginkgo v1.8.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE= +github.com/onsi/gomega v1.5.0 h1:izbySO9zDPmjJ8rDjLvkA2zJHIo+HkYXHnf7eN7SSyo= +github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY= +github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc= +github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic= +github.com/pelletier/go-toml v1.4.0 h1:u3Z1r+oOXJIkxqw34zVhyPgjBsm6X2wn21NWs/HfSeg= +github.com/pelletier/go-toml v1.4.0/go.mod h1:PN7xzY2wHTK0K9p34ErDQMlFxa51Fk0OUruD3k1mMwo= +github.com/pkg/errors v0.8.0 h1:WdK/asTD0HN+q6hsWO3/vpuAkAr+tw6aNJNDFFf0+qw= +github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= +github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= +github.com/prometheus/client_golang v0.9.3 h1:9iH4JKXLzFbOAdtqv/a+j8aewx2Y8lAjAydhbaScPF8= +github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8= +github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= +github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE= +github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA= +github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro= +github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/common v0.4.1 h1:K0MGApIoQvMw27RTdJkPbr3JZ7DNbtxQNyi5STVM6Kw= +github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4= +github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk= +github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084 h1:sofwID9zm4tzrgykg80hfFph1mryUeLRsUfoocVVmRY= +github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/procfs v0.0.2 h1:6LJUbpNm42llc4HRCuvApCSWB/WfhuNo9K98Q9sNGfs= +github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA= +github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU= +github.com/robfig/cron v1.1.0 h1:jk4/Hud3TTdcrJgUOBgsqrZBarcxl6ADIjSC2iniwLY= +github.com/robfig/cron v1.1.0/go.mod h1:JGuDeoQd7Z6yL4zQhZ3OPEVHB7fL6Ka6skscFHfmt2k= +github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg= +github.com/rogpeppe/go-internal v1.1.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.2.2/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk= +github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4= +github.com/rubenv/sql-migrate v0.0.0-20190327083759-54bad0a9b051 h1:p32bQkgLiadYiOqs294BAx/7f1Aerfva8rj+rVvzR0A= +github.com/rubenv/sql-migrate v0.0.0-20190327083759-54bad0a9b051/go.mod h1:WS0rl9eEliYI8DPnr3TOwz4439pay+qNgzJoVya/DmY= +github.com/schollz/closestmatch v2.1.0+incompatible h1:Uel2GXEpJqOWBrlyI+oY9LTiyyjYS17cCYRqP13/SHk= +github.com/schollz/closestmatch v2.1.0+incompatible/go.mod h1:RtP1ddjLong6gTkbtmuhtR2uUrrJOpYzYRvbcPAid+g= +github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= +github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k= +github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q= +github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4= +github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= +github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM= +github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA= +github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ= +github.com/spf13/afero v1.2.2 h1:5jhuqJyZCZf2JRofRvN/nIFgIWNzPa3/Vz8mYylgbWc= +github.com/spf13/afero v1.2.2/go.mod h1:9ZxEEn6pIJ8Rxe320qSDBk6AsU0r9pR7Q4OcevTdifk= +github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8= +github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE= +github.com/spf13/cobra v0.0.3 h1:ZlrZ4XsMRm04Fr5pSFxBgfND2EBVa1nLpiy1stUsX/8= +github.com/spf13/cobra v0.0.3/go.mod h1:1l0Ry5zgKvJasoi3XT1TypsSe7PqH0Sj9dhYf7v3XqQ= +github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo= +github.com/spf13/jwalterweatherman v1.1.0 h1:ue6voC5bR5F8YxI5S67j9i582FU4Qvo2bmqnqMYADFk= +github.com/spf13/jwalterweatherman v1.1.0/go.mod h1:aNWZUN0dPAAO/Ljvb5BEdw96iTZ0EXowPYD95IqWIGo= +github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg= +github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4= +github.com/spf13/viper v1.4.0 h1:yXHLWeravcrgGyFSyCgdYpXQ9dR9c/WED3pg1RhxqEU= +github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= +github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q= +github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI= +github.com/tellytv/go.schedulesdirect v0.0.0-20180903021109-bb2d9eec79e9 h1:0CH/kIZdr6lUbW8R6+ZJS9GskQu2Mpg4zMfuUx6hz1c= +github.com/tellytv/go.schedulesdirect v0.0.0-20180903021109-bb2d9eec79e9/go.mod h1:pBZcxidsU285nwpDZ3NQIONgAyOo4wiUoOutTMu7KU4= +github.com/tellytv/go.xtream-codes v0.0.0-20190427212115-45e8162ba888 h1:AvoYr+NW3npUjbVjBMihfM699o+xlG6N5ftA+xEjurE= +github.com/tellytv/go.xtream-codes v0.0.0-20190427212115-45e8162ba888/go.mod h1:gWtQ2uZJ49dBh4cWiFuz7Tb5ALxLB9hY1GFoz34lsGs= +github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U= +github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc= +github.com/ugorji/go v1.1.5-pre h1:jyJKFOSEbdOc2HODrf2qcCkYOdq7zzXqA9bhW5oV4fM= +github.com/ugorji/go v1.1.5-pre/go.mod h1:FwP/aQVg39TXzItUBMwnWp9T9gPQnXw4Poh4/oBQZ/0= +github.com/ugorji/go/codec v1.1.5-pre h1:5YV9PsFAN+ndcCtTM7s60no7nY7eTG3LPtxhSwuxzCs= +github.com/ugorji/go/codec v1.1.5-pre/go.mod h1:tULtS6Gy1AE1yCENaw4Vb//HLH5njI2tfCQDUqRd8fI= +github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU= +github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q= +github.com/ziutek/mymysql v1.5.4 h1:GB0qdRGsTwQSBVYuVShFBKaXSnSnYYC2d9knnE1LHFs= +github.com/ziutek/mymysql v1.5.4/go.mod h1:LMSpPZ6DbqWFxNCHW77HeMg9I646SAhApZ/wKdgO/C0= +github.com/zsais/go-gin-prometheus v0.0.0-20181030200533-58963fb32f54 h1:pnZSRJZsHRBoamnhJn8/mXK+H6NnHoA2sD+7xw1vi3w= +github.com/zsais/go-gin-prometheus v0.0.0-20181030200533-58963fb32f54/go.mod h1:Slirjzuz8uM8Cw0jmPNqbneoqcUtY2GGjn2bEd4NRLY= +gitlab.com/NebulousLabs/go-upnp v0.0.0-20181011194642-3a71999ed0d3 h1:qXqiXDgeQxspR3reot1pWme00CX1pXbxesdzND+EjbU= +gitlab.com/NebulousLabs/go-upnp v0.0.0-20181011194642-3a71999ed0d3/go.mod h1:sleOmkovWsDEQVYXmOJhx69qheoMTmCuPYyiCFCihlg= +go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU= +go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE= +go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0= +go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= +golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= +golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= +golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= +golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= +golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c h1:uOCk1iQW6Vc18bnC13MfzScl+wdKBmM9Y9kU7Z83/lw= +golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65 h1:+rhAzEzT3f4JtomfC371qB+0Ola2caSKcY69NUBZrRQ= +golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= +golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606122018-79a91cf218c4 h1:3i7qG/aA9NUAzdnJHfhgxSKSmxbAebomYR5IZgFbC5Y= +golang.org/x/sys v0.0.0-20190606122018-79a91cf218c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= +golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= +golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= +golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= +golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= +golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= +golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190404132500-923d25813098/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= +google.golang.org/appengine v1.6.0 h1:Tfd7cKwKbFRsI8RMAD3oqqw7JPFRrvFlOsfbgVkjOOw= +google.golang.org/appengine v1.6.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= +google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= +google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= +gopkg.in/alecthomas/kingpin.v2 v2.2.6 h1:jMFz6MfLP0/4fUyZle81rXUoxOBFi19VUFKVDOQfozc= +gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY= +gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI= +gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4= +gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= +gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM= +gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE= +gopkg.in/go-playground/validator.v8 v8.18.2 h1:lFB4DoMU6B626w8ny76MV7VX6W2VHct2GVOI3xgiMrQ= +gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y= +gopkg.in/gorp.v1 v1.7.2 h1:j3DWlAyGVv8whO7AcIWznQ2Yj7yJkn34B8s63GViAAw= +gopkg.in/gorp.v1 v1.7.2/go.mod h1:Wo3h+DBQZIxATwftsglhdD/62zRFPhGhTiu5jUJmCaw= +gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= +gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= +gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74= +gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= +gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI= +honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= diff --git a/internal/api/tuner.go b/internal/api/tuner.go index 4f0b6cf..4be3166 100644 --- a/internal/api/tuner.go +++ b/internal/api/tuner.go @@ -11,8 +11,8 @@ import ( upnp "github.com/NebulousLabs/go-upnp/goupnp" "github.com/gin-gonic/gin" + "github.com/gofrs/uuid" "github.com/koron/go-ssdp" - uuid "github.com/satori/go.uuid" "github.com/sirupsen/logrus" ccontext "github.com/tellytv/telly/internal/context" "github.com/tellytv/telly/internal/metrics" diff --git a/internal/m3uplus/main.go b/internal/m3uplus/main.go index 9c6053b..d3b61d0 100644 --- a/internal/m3uplus/main.go +++ b/internal/m3uplus/main.go @@ -96,7 +96,7 @@ func decodeLine(playlist *Playlist, line string, lineNumber int) error { playlist.Tracks = append(playlist.Tracks, track) - case strings.HasPrefix(line, "http"): + case strings.HasPrefix(line, "http") || strings.HasPrefix(line, "udp"): playlist.Tracks[len(playlist.Tracks)-1].URI = line } diff --git a/internal/models/guide_source.go b/internal/models/guide_source.go index 199e6d3..fdd43e0 100644 --- a/internal/models/guide_source.go +++ b/internal/models/guide_source.go @@ -5,9 +5,9 @@ import ( "fmt" "time" + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/guideproviders" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // GuideSourceDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/internal/models/guide_source_channel.go b/internal/models/guide_source_channel.go index 5f086bd..c654e90 100644 --- a/internal/models/guide_source_channel.go +++ b/internal/models/guide_source_channel.go @@ -5,9 +5,9 @@ import ( "fmt" "time" + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/guideproviders" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // GuideSourceChannelDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/internal/models/guide_source_programme.go b/internal/models/guide_source_programme.go index 865a61c..4812e60 100644 --- a/internal/models/guide_source_programme.go +++ b/internal/models/guide_source_programme.go @@ -5,9 +5,9 @@ import ( "fmt" "time" + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/xmltv" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // GuideSourceProgrammeDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/internal/models/lineup.go b/internal/models/lineup.go index d969b52..d5d8f79 100644 --- a/internal/models/lineup.go +++ b/internal/models/lineup.go @@ -7,10 +7,10 @@ import ( "strings" "time" + "github.com/Masterminds/squirrel" upnp "github.com/NebulousLabs/go-upnp/goupnp" + "github.com/gofrs/uuid" "github.com/jmoiron/sqlx" - "github.com/satori/go.uuid" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // LineupDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/internal/models/lineup_channel.go b/internal/models/lineup_channel.go index f6368c1..4af4393 100644 --- a/internal/models/lineup_channel.go +++ b/internal/models/lineup_channel.go @@ -5,8 +5,8 @@ import ( "fmt" "time" + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // LineupChannelDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/internal/models/main.go b/internal/models/main.go index 0363a79..2126352 100644 --- a/internal/models/main.go +++ b/internal/models/main.go @@ -1,9 +1,9 @@ package models import ( + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" "github.com/sirupsen/logrus" - "gopkg.in/Masterminds/squirrel.v1" ) var sq = squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar) // nolint diff --git a/internal/models/video_source.go b/internal/models/video_source.go index 9ced8f7..9f92168 100644 --- a/internal/models/video_source.go +++ b/internal/models/video_source.go @@ -3,9 +3,9 @@ package models import ( "time" + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" "github.com/tellytv/telly/internal/videoproviders" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // VideoSourceDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/internal/models/video_source_track.go b/internal/models/video_source_track.go index 739d76b..e20692d 100644 --- a/internal/models/video_source_track.go +++ b/internal/models/video_source_track.go @@ -3,8 +3,8 @@ package models import ( "time" + "github.com/Masterminds/squirrel" "github.com/jmoiron/sqlx" - squirrel "gopkg.in/Masterminds/squirrel.v1" ) // VideoSourceTrackDB is a struct containing initialized the SQL connection as well as the APICollection. diff --git a/main.go b/main.go index a99c8d2..8bdddf0 100644 --- a/main.go +++ b/main.go @@ -34,6 +34,20 @@ var ( func main() { + // Discovery flags + flag.String("discovery.device-id", "12345678", "8 alpha-numeric characters used to uniquely identify the device. $(TELLY_DISCOVERY_DEVICE_ID)") + flag.String("discovery.device-friendly-name", "telly", "Name exposed via discovery. Useful if you are running two instances of telly and want to differentiate between them $(TELLY_DISCOVERY_DEVICE_FRIENDLY_NAME)") + flag.String("discovery.device-auth", "telly123", "Only change this if you know what you're doing $(TELLY_DISCOVERY_DEVICE_AUTH)") + flag.String("discovery.device-manufacturer", "Silicondust", "Manufacturer exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MANUFACTURER)") + flag.String("discovery.device-model-number", "HDTC-2US", "Model number exposed via discovery. $(TELLY_DISCOVERY_DEVICE_MODEL_NUMBER)") + flag.String("discovery.device-firmware-name", "hdhomeruntc_atsc", "Firmware name exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_NAME)") + flag.String("discovery.device-firmware-version", "20150826", "Firmware version exposed via discovery. $(TELLY_DISCOVERY_DEVICE_FIRMWARE_VERSION)") + flag.Bool("discovery.ssdp", true, "Turn on SSDP announcement of telly to the local network $(TELLY_DISCOVERY_SSDP)") + + // Regex/filtering flags + flag.Bool("filter.regex-inclusive", false, "Whether the provided regex is inclusive (whitelisting) or exclusive (blacklisting). If true (--filter.regex-inclusive), only channels matching the provided regex pattern will be exposed. If false (--no-filter.regex-inclusive), only channels NOT matching the provided pattern will be exposed. $(TELLY_FILTER_REGEX_INCLUSIVE)") + flag.String("filter.regex", ".*", "Use regex to filter for channels that you want. A basic example would be .*UK.*. $(TELLY_FILTER_REGEX)") + // Web flags flag.StringP("web.listen-address", "l", ":6077", "Address to listen on for web interface, API and telemetry $(TELLY_WEB_LISTEN_ADDRESS)") @@ -89,6 +103,8 @@ func main() { validateConfig() + viper.Set("discovery.device-uuid", fmt.Sprintf("%s-AE2A-4E54-BBC9-33AF7D5D6A92", viper.GetString("discovery.device-id"))) + if log.Level == logrus.DebugLevel { js, jsErr := json.MarshalIndent(viper.AllSettings(), "", " ") if jsErr != nil { @@ -146,6 +162,10 @@ func main() { } func validateConfig() { + if !(viper.IsSet("source")) { + log.Warnln("There is no source element in the configuration, the config file is likely missing.") + } + var addrErr error if _, addrErr = net.ResolveTCPAddr("tcp", viper.GetString("web.listenaddress")); addrErr != nil { log.WithError(addrErr).Panic("Error when parsing Listen address, please check the address and try again.") From dbd02b95c2b9ba5caf958cbed970f5ab08583062 Mon Sep 17 00:00:00 2001 From: Matt Stevens Date: Mon, 10 Jun 2019 20:00:28 +0100 Subject: [PATCH 179/182] TNG: Build Process Fixes (Modern Go 1.11) (#253) * packr clean - these files shouldn't be included in the git repo packr should be run before release builds, but then packr clean should be called to not dirty the repo with these files. * remove make dep since dependencies rely on go modules now * replace deprecated gometalinter with golangci-lint gometalinter is fully deprecated and no longer works, preconfigured .golangci.yml with almost equal linters * backport Makefile & circleci changes from dev branch --- .circleci/config.yml | 68 ++--------------------------- .golangci.yml | 31 +++++++++++++ .gometalinter.json | 41 ----------------- Makefile | 54 ++++------------------- internal/api/a_api-packr.go | 19 -------- internal/context/a_context-packr.go | 13 ------ 6 files changed, 43 insertions(+), 183 deletions(-) create mode 100644 .golangci.yml delete mode 100644 .gometalinter.json delete mode 100644 internal/api/a_api-packr.go delete mode 100644 internal/context/a_context-packr.go diff --git a/.circleci/config.yml b/.circleci/config.yml index bc83b7c..b29cddc 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -1,73 +1,11 @@ ---- version: 2 - jobs: - test: - docker: - - image: circleci/golang:1.10 - working_directory: /go/src/github.com/tellytv/telly - - steps: - - checkout - - setup_remote_docker - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - - run: make promu - - run: make - build: - machine: true - working_directory: /home/circleci/.go_workspace/src/github.com/tellytv/telly - environment: - GOPATH: /home/circleci/.go_workspace - - steps: - - checkout - - run: mkdir /home/circleci/.go_workspace/bin - - run: curl https://raw.githubusercontent.com/golang/dep/master/install.sh | sh - - run: make promu - - run: make dep - - run: promu crossbuild -v - - persist_to_workspace: - root: . - paths: - - .build - - docker_hub_master: docker: - image: circleci/golang:1 steps: - checkout - # - run: go get -u github.com/alecthomas/gometalinter - # - run: gometalinter --install - - run: go test -v ./... - # - run: gometalinter --config=.gometalinter.json ./... - -workflows: - version: 2 - telly: - jobs: - - test: - filters: - tags: - only: /.*/ - - build: - filters: - tags: - only: /.*/ - - docker_hub_master: - requires: - - test - - build - filters: - branches: - only: master - - docker_hub_release_tags: - requires: - - test - - build - filters: - tags: - only: /^v[0-9]+(\.[0-9]+){2}(-.+|[^-.]*)$/ - branches: - ignore: /.*/ + - run: go get -u github.com/golangci/golangci-lint/cmd/golangci-lint + - run: golangci-lint run ./... + - run: go test -v ./... \ No newline at end of file diff --git a/.golangci.yml b/.golangci.yml new file mode 100644 index 0000000..2b6f956 --- /dev/null +++ b/.golangci.yml @@ -0,0 +1,31 @@ +linters-settings: + goimports: + local-prefixes: github.com/telly/telly + +linters: + enable: + - deadcode + - errcheck + - gochecknoinits + - goconst + - gofmt + - goimports + - golint + - gosec + - ineffassign + - interfacer + - megacheck + - misspell + - nakedret + - structcheck + - unconvert + - unparam + - varcheck + - vet + - vetshadow + disable: + - unused + +run: + skip-files: + - ".*-packr.go$" \ No newline at end of file diff --git a/.gometalinter.json b/.gometalinter.json deleted file mode 100644 index 6720d06..0000000 --- a/.gometalinter.json +++ /dev/null @@ -1,41 +0,0 @@ -{ - "Enable": [ - "deadcode", - "errcheck", - "gochecknoinits", - "goconst", - "gofmt", - "goimports", - "golint", - "gosec", - "gotype", - "gotypex", - "ineffassign", - "interfacer", - "megacheck", - "misspell", - "nakedret", - "safesql", - "structcheck", - "test", - "testify", - "unconvert", - "unparam", - "varcheck", - "vet", - "vetshadow" - ], - "Exclude": [ - "^vendor\/", - ".*-packr.go.*", - ".*tableName is unused.*", - "error return value not checked .*c.AbortWithError.*" - ], - "Deadline": "5m", - "Skip": ["../vendor"], - "Sort": [ - "path", - "linter" - ], - "Vendor": true -} diff --git a/Makefile b/Makefile index 99c44df..38379ae 100644 --- a/Makefile +++ b/Makefile @@ -1,32 +1,19 @@ GO := go GOPATH ?= $(HOME)/go PROMU := $(GOPATH)/bin/promu - -GO ?= go -GOFMT ?= $(GO)fmt -FIRST_GOPATH := $(firstword $(subst :, ,$(shell $(GO) env GOPATH))) -PROMU := $(FIRST_GOPATH)/bin/promu - -GOMETALINTER_BINARY := $(FIRST_GOPATH)/bin/gometalinter -DEP_BINARY := $(FIRST_GOPATH)/bin/dep +CILINT := $(GOPATH)/bin/golangci-lint PREFIX ?= $(shell pwd) BIN_DIR ?= $(shell pwd) DOCKER_IMAGE_NAME ?= telly -DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD)) -DOCKER_REPO ?= tellytv +DOCKER_IMAGE_TAG ?= $(subst /,-,$(shell git rev-parse --abbrev-ref HEAD)) - -all: dep style build test +all: format build test style: @echo ">> checking code style" - @$(GO) get -u github.com/alecthomas/gometalinter - @$(GOMETALINTER_BINARY) --config=.gometalinter.json --install ./... - -dep: $(DEP_BINARY) - @echo ">> installing dependencies" - @$(DEP_BINARY) ensure -vendor-only -v + @$(GO) get -u github.com/golangci/golangci-lint/cmd/golangci-lint + @$(CILINT) run ./... test: @echo ">> running tests" @@ -50,11 +37,7 @@ tarballs: promu build: promu @echo ">> building binaries" - @$(PROMU) build -v --prefix $(PREFIX) - -crossbuild: promu - @echo ">> building binaries" - @$(PROMU) crossbuild -v + @$(PROMU) build --prefix $(PREFIX) tarball: promu @echo ">> building release tarball" @@ -62,28 +45,9 @@ tarball: promu docker: cross @echo ">> building docker image" - @docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . - -docker-150: - @echo ">> building docker image" - @docker build -t "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):v1.5.0" . - -docker-publish: - @echo ">> publishing docker image" - @docker push "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME)" - -docker-tag-latest: - @docker tag "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" "$(DOCKER_REPO)/$(DOCKER_IMAGE_NAME):latest" + @docker build -t "$(DOCKER_IMAGE_NAME):$(DOCKER_IMAGE_TAG)" . promu: - @GO111MODULE=off \ - GOOS=$(shell uname -s | tr A-Z a-z) \ - GOARCH=$(subst x86_64,amd64,$(patsubst i%86,386,$(shell uname -m))) \ - $(GO) get -u github.com/prometheus/promu - - -.PHONY: all style dep format build test vet tarball docker docker-publish docker-tag-latest promu - + @$(GO) get -u github.com/prometheus/promu -run: - go run *.go +.PHONY: all style format build test vet tarball docker promu \ No newline at end of file diff --git a/internal/api/a_api-packr.go b/internal/api/a_api-packr.go deleted file mode 100644 index 6e15397..0000000 --- a/internal/api/a_api-packr.go +++ /dev/null @@ -1,19 +0,0 @@ -// Code generated by github.com/gobuffalo/packr. DO NOT EDIT. - -package api - -import "github.com/gobuffalo/packr" - -// You can use the "packr clean" command to clean up this, -// and any other packr generated files. -func init() { - packr.PackJSONBytes("../../frontend/dist/telly-fe", "3rdpartylicenses.txt", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/github-logo.svg", "\"H4sIAAAAAAAA/3STy24aSxCG9+cpSrPvn7p09eUIWMSLZJOHABvhkcbGMmPjvH1UYxyhSJGQ+Gq6/rp19fr8fqTd67hL025/mKbDw/7XZjiPTy/TYbw/PZ/TcZwf3/YpjIFeT9NhM4xPx4Hex8Pl2+ljMzAxaSbNA308Tc/nzfA4zy//r1aXywUXw+n1uFJmXp3fj8N2PY/zdKDx4d9Ztt/H+cfbnsJYrxb/7fplNz/Sw2b4KUrQXu9TQTHiJEoOqxYgShwWGxmyNepo1KDsJAJrjgIRQ9ME9bb8e63ECdo8gSUJOAd40iCDWUPVnDI4axIUucG7jKxK0sCVDMWMpOIW7yNiqwk1Z3DLCVX7HyCJ4sIkQbMWtpW/mOvywUnROCTGHv11R+8Nwi2h1oIsNS2HqCWq4+ihFE+w5MglPprplR19GR9MkEu4XlN6MqgmiIWSLcFzErgahONQaqG4dAFzuKiSwRYteknQEgX3lmC9kyXkmD9YwVwoxgqxRkbLgUJbhPeIErcQcW4QJYe6uCG2DK0aJHylFtTiWGankb8LfYljEXLcVczMyVHUo/Ea3BVZYQUtBNwX0E9RzK0sCxC5+hWjnGgaJg4VlI6mDq93yvDipAruGu9AKvxKuiwqx6ZqTV9b+vkbVtt1vIjtf78DAAD//2XIUFKDAwAA\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "assets/logo.svg", "\"H4sIAAAAAAAA/2xUbWtbRxP9fn/Fee7zpYGO787MvhbLobFDKDRtSNyUfDSyYovKlpEutsmvL2elNG2pwbuj3Z23M+fc05fPdxs8rnb79fZ+MepJGLGfr+6vrzbb+9VivN+OL8+G0/9d/Hp++enda+wfb/Dut1c//3SOUabpdz+fpovLC3z4+AYWgoYW4jS9/mUcMN7O88MP0/T09HTy5Cfb3c10+X7io+n963P58PGN/OVxcXkx7R9vNJxcz9fj2XDKPP+s6vluc79f/EdQCyHQeRzwtL6ebxdjUjsJ/e9hHnG7Wt/czv8+fVyvnl5tnxdjQMC3q7+Z44CH3Wq/2j2uftw/rJbz+6t5vV2Mz2/X15/erq9xt1rNrPUG8+7qfv95u7tbjN3cXM2r78IxzvffQr7Afnm14ZUeruSr9WIcPq83m8X4/2Ny7Ofd9o8+gfsVszxczbe4XoxvveaKFLRiKTlCkkJSqZBEq+UKadGwEasJYjVDEpvs60DMYUGxFKsGqw6JtSEWvtOGWBWSE9QhmgOkxKOhsTBMdBgkpsF5GNWw8RAhrvo1S1+lFoMkVhkaJEJqC5AGaVYhWhgx0W8Q18QkDeK1hzKIFfYFcXpUSMzHOjIrhijT1HIw1JpiEwZRCw2WQWiWUXnr6C2kBI0RYhaRCyQXaGKTFmB+rKYEPkBU8+FgNPpCU0DMHS5NDZ4iPCg2MaCyYWUHx40Vl4alFD7WQczpyb5qgWuGeEGFuGmHuVmGFmykFgfDdAxTQKoNqWUs3SLc6pBDQdaG7AE5JpjDCqIiNa5FO5nZdIB2wFI8GJVTccLWILkOEu0L7kStz6J6xTJ5RxglOiQbKlsnVZQH6uQN59IajJFyidA8iBYDm6qNIDI5UXSHeDJIIz/NiWtnFicdvi4H4LNyvD6INsIX+JOwF46WHLEQOvcsFtDDSwHJFGuGNhIko7H6GPl7EK0RzsxeoBRHTCDcjFs1QCl0KFEMBK96A128wFJFLORIQnIbtBVYhYagiAGaYoDFL7jTVoilKpaqbDKjd6JJD4aHxqKV4CiLosb4b5G6ckgNHS4qFmJdvxwHScT+jZzheIyTltzgjG8+UNp9tonvKjgPM+TUN2YPaA0Ote6rOYGcSaipn1HMLDTGwZTnFqFF+3agsh2Izw+Ea+cKi66KZSaDDWoJ0lLXhmi2ToYYQZhL6xu1Eg4UYB+BVdbDY/HDd0YKGUDB968B6xJPnCAkkzV+CCMUdceqI6MQuhSSElISvB8blXfUeu4+iUKuB2TIBfKoVUSoVdZIZKKiKZQ4JR46yOkaqU4KRGEMa/HLOJ0Np9MNl/3jzdnwZwAAAP//l/1vxkAHAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "favicon.ico", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "index.html", "\"H4sIAAAAAAAA/5RSvW7cMAze7ylUrldb6FYUkjt3yNLkBXgybTORRUFiLjGQhy98StND0eE62fw+fD+U5D6NEnTLZBZd43Bw+8dETLMHSrADhONwMMatpGjCgqWSenjWqfsKF0JZIw0PFOPmbBt2+ISVzFJo8mDhj0PClTycmV6yFAUTJCkl9fDCoy5+pDMH6i7DZ8OJlTF2NWAk/6XZRE5PplD0wEESmL2+B15xJvvaNazlTnjex56DwHD40DZyUc31m7WTJK39LDJHwsy1D7LaUOv3CVeOm/8pJ1F5u+c58RO+3S9Y6PhAYTneSRJoTapukepCpFcdb8jZ6/0OukOlwhiPP4Kk+i/jq9Wv8PechvShVhicbdfmTjJul0KYc1dEdHD24/fgaiic9f0ElV7VPuIZGwqmluChPCfllfrHi22jhluEWeI2cYz1/6UrcvpLZdsmzrZ3+isAAP//6CCT07gCAAA=\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "main.js", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "polyfills.js", "\"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\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "runtime.js", "\"H4sIAAAAAAAA/4xTTW/bMAz9K0kOhgSzgrNjXGL3AUN3F4RCUejGmyoJstSscPzfBzlxsgIdsBv18R7Jx8d1l51JvXcs8nGJV8SIj52P7E3HVYIABkk2CjSS3CrokOQXBRYbGFCq1j4aYcm9pGNr65p7GdBIq1RVDSLk4ci8DEo2ikMJsGkLdVr1bqX50/4nmSRC9Mmn90DiqIenk/sRfaCY3oXR1jINiVcVizIp1DIpPjP0VdUz4u2wJOeDGI59lxhnvI2UcnSrPFcgdAj2nWXozmepODjGp1u3jt2bjUDYtPSYF06q6/urwyxJQcJ1Awa3rXl0yz9T17xZI3rppCmts4TrLW9TVbEshmB7Q4weHmDLIWJgQQzoiiZ8ulYap1ltHCfwODa7ZoJc1L3VGcpU+o4lSYpfQSUW9Dv4mIb2UmK5wrHfEdjdegvXx904TYsmsYBmYd2CBQf3OHBwwpYmb3dTEK8YIQiDCYI44N03QOD4GIQvIT+frxM9UNc7WuY4fxuNd13/kqPeW5prc/mVrqcGXijt3MQnCCLi3778F+Pm+ZmG7/6QLW1gfNM2F54Lg/vAUJQhjFUVxR3z9faDj4syJYnONk27Tx5vAgZxYAQbvQHiQCWd/yDIDfJf7i6AwhFws5lnaPDUu4M/iRPtgza/vg3ehc/uiplBo7l4fN+7AzO8vRyRwKARw2y8y8IU7q6s331fu7rmxIzsFJ9T96jbshxMKt7+CQAA//9/VcMtHQQAAA==\"") - packr.PackJSONBytes("../../frontend/dist/telly-fe", "styles.css", "\"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\"") -} diff --git a/internal/context/a_context-packr.go b/internal/context/a_context-packr.go deleted file mode 100644 index 36bdd56..0000000 --- a/internal/context/a_context-packr.go +++ /dev/null @@ -1,13 +0,0 @@ -// Code generated by github.com/gobuffalo/packr. DO NOT EDIT. - -package context - -import "github.com/gobuffalo/packr" - -// You can use the "packr clean" command to clean up this, -// and any other packr generated files. -func init() { - packr.PackJSONBytes("../../migrations", "20180905174455-initial.sql", "\"H4sIAAAAAAAA/9xXSW/jNhS+61fwFhu1g8TZZjCXKjY9EerIqUwVmZPAERmbqCRquDjjf19Ym0lZSt2gRYDqyPe97XsLKWc8Br+kbC2woiDMHWcaQBdBgNz7BQTeHPhLBOCzt0IrsGWE8khyLWIKBg4AjAD783wEv8IAPAXeoxt8A7/Bb8AN0dLzpwF8hD4aOQBkOKWWFoLPhSAXfO9CNII/3GD64AaD2+sh8MPFYg/SkgrLQhcox1K+ckHeBH3HkkZaJEdxpFfaOj8I8M9IKkFxKq18i7hyghWNXgT9oWkW7wolMINzN1wgcPYrwSzZne2RLM25UJREWFXmvUe4Qu7jUwOfhkEAfRQ1Emf45eTSRErg+M/OAp1UH8sWI2aS7dLVxJSkRI07QyXha96lonZ5p6kYK7rmYtc+p/k6MtOpz9tsnkDmyHEAmC8D6H319xQMWhkPQQDnMID+FNrMDhgZ/l0l1poR+v8Zkp9porbmNLTjiAhW2BR87CCY9EfxBmcZTd4/CqW1g6rR1yUxB1EfL/V5TdO/1b/Tpb9Cgev5CFRpRjpjPzQFoe/9HkIwqIMfNbEOR63GryFWx5sU/tOOj3LB1wKnadn7HfwVM17V5XiNYKFMjg4ZA0Azu4KWcN9ypnDmIvhB1WgY6K9Hlf+oTHi0T+2/KU3CMqrz7jX07k1kFkySvC27Xy4X0PUbwlAQFqVImFQ0izAhgkp5sHNYDZeTu/OL84vzy2I7ECZjvqViZ6i8hd8XrifB4r7RGRWyV5ziTL/gWGlxWK22txVLWMwzoqUq/KWc0CSy2bE1HmYPPKWBzgB8RtCfmWo6/d7n6GGGpuNJuCrgL0ykr1hQ05EN35ANT6nQmYojrGRsq22pkIxnx2qTi8ubi0+T25JrumUxte7XI66vrm9u7z6ZcKzVpgeuaFIt+QqrtWG82/TYhRN3fA1vrsf399PP46srd343u5ndup8nZ8YrQwmcybraLS6UygtoLCg2b5YTZ/m0eXrzXjltqCpDnTeLYirpfhpVe75pnlpQvlGKZ19p0rBWroxa1X7ObdqxV7NbdBDecsGMrWrIjth9z6OrocDacOXpoOOuspPsfaOViC4DbSZ6N2uNaTas9ZM046+Z48yC5VPVIqb3L32CMixLbLrsFdSxWICSpI6jA/qvAAAA//+mYnMb2A0AAA==\"") - packr.PackJSONBytes("../../migrations", "20180913140221-AddVideoTrackUniqueConstraint.sql", "\"H4sIAAAAAAAA/+LS1VXQzs1ML0osSVUILeDicg5ydQxxVQj18wwMdVXw9HNxjVAoKUpMzo4vzcssLE1V8PdTKMtMSc2PL84vLUpOjQdLaqAIZaboKBSXFKUm5sZnpmhac6FY4pJfnscFCAAA//+8qzXOdwAAAA==\"") - packr.PackJSONBytes("../../migrations", "dbconfig.yml", "\"H4sIAAAAAAAA/6zMMQ4CMQxE0T6n8Alo6HwbbzxClrzr4DhI3B6Fjp5ynkZf8YLHOHEVNyI1cfRimk+3wn2TlMxY2cFUcH/f9Pg+k+m0R0pZXLMRlRyOH2sjQ1ff4//xTwAAAP//TU5AhLoAAAA=\"") -} From 4f8e5ab479674e4025c1ab04c8f72a9c951331f5 Mon Sep 17 00:00:00 2001 From: Matt Stevens Date: Mon, 10 Jun 2019 22:39:23 +0100 Subject: [PATCH 180/182] TNG: Guide & Video Providers, Update & Delete API routes (#254) * packr clean - these files shouldn't be included in the git repo packr should be run before release builds, but then packr clean should be called to not dirty the repo with these files. * remove make dep since dependencies rely on go modules now * replace deprecated gometalinter with golangci-lint gometalinter is fully deprecated and no longer works, preconfigured .golangci.yml with almost equal linters * backport Makefile & circleci changes from dev branch * Provide API endpoints for updating and deleting video and guide sources * Update frontend submodule to use the new HTTP API methods for editing/deleting --- frontend | 2 +- internal/api/guide_source.go | 43 ++++++++++++++++++++++++++++-- internal/api/main.go | 4 +++ internal/api/video_source.go | 42 ++++++++++++++++++++++++++++- internal/commands/guide_updates.go | 2 +- internal/models/guide_source.go | 30 ++++++++++++++++----- internal/models/video_source.go | 28 ++++++++++++------- 7 files changed, 129 insertions(+), 22 deletions(-) diff --git a/frontend b/frontend index ad6c1a1..902a435 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit ad6c1a1a6a3737f61bad0eb248fc0c8dccc43c81 +Subproject commit 902a435bbb7d64e46c2e360c16dfc8da37909c28 diff --git a/internal/api/guide_source.go b/internal/api/guide_source.go index c9a1c3b..d4de2e1 100644 --- a/internal/api/guide_source.go +++ b/internal/api/guide_source.go @@ -42,7 +42,7 @@ func addGuide(cc *context.CContext, c *gin.Context) { return } - if updateErr := cc.API.GuideSource.UpdateGuideSource(newGuide.ID, lineupMetadata); updateErr != nil { + if updateErr := cc.API.GuideSource.UpdateProviderData(newGuide.ID, lineupMetadata); updateErr != nil { c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while updating guide source with provider state: %s", updateErr)) return } @@ -68,6 +68,45 @@ func addGuide(cc *context.CContext, c *gin.Context) { } } +func saveGuideSource(cc *context.CContext, c *gin.Context) { + guideSourceID := c.Param("sourceId") + + iGuideSourceID, err := strconv.ParseInt(guideSourceID, 0, 32) + if err != nil { + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + var payload models.GuideSource + if c.BindJSON(&payload) == nil { + provider, providerErr := cc.API.GuideSource.UpdateGuideSource(int(iGuideSourceID), payload) + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + c.JSON(http.StatusOK, provider) + } +} + +func deleteGuideSource(cc *context.CContext, c *gin.Context) { + guideSourceID := c.Param("sourceId") + + iGuideSourceID, err := strconv.ParseInt(guideSourceID, 0, 32) + if err != nil { + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + err = cc.API.GuideSource.DeleteGuideSource(int(iGuideSourceID)) + if err != nil { + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + c.Status(http.StatusNoContent) +} + func getGuideSources(cc *context.CContext, c *gin.Context) { sources, sourcesErr := cc.API.GuideSource.GetAllGuideSources(true) if sourcesErr != nil { @@ -149,7 +188,7 @@ func subscribeToLineup(guideSource *models.GuideSource, provider guideproviders. return } - if updateErr := cc.API.GuideSource.UpdateGuideSource(guideSource.ID, lineupMetadata); updateErr != nil { + if updateErr := cc.API.GuideSource.UpdateProviderData(guideSource.ID, lineupMetadata); updateErr != nil { c.AbortWithError(http.StatusInternalServerError, fmt.Errorf("error while updating guide source with provider state: %s", updateErr)) return } diff --git a/internal/api/main.go b/internal/api/main.go index 5e63926..7032e8e 100644 --- a/internal/api/main.go +++ b/internal/api/main.go @@ -40,6 +40,8 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/guide_sources", wrapContext(cc, getGuideSources)) apiGroup.POST("/guide_sources", wrapContext(cc, addGuide)) + apiGroup.PUT("/guide_sources/:sourceId", wrapContext(cc, saveGuideSource)) + apiGroup.DELETE("/guide_sources/:sourceId", wrapContext(cc, deleteGuideSource)) apiGroup.GET("/guide_sources/channels", wrapContext(cc, getAllChannels)) apiGroup.GET("/guide_sources/programmes", wrapContext(cc, getAllProgrammes)) @@ -52,6 +54,8 @@ func ServeAPI(cc *context.CContext) { apiGroup.GET("/video_sources", wrapContext(cc, getVideoSources)) apiGroup.POST("/video_sources", wrapContext(cc, addVideoSource)) + apiGroup.PUT("/video_sources/:sourceId", wrapContext(cc, saveVideoSource)) + apiGroup.DELETE("/video_sources/:sourceId", wrapContext(cc, deleteVideoSource)) apiGroup.GET("/video_sources/tracks", wrapContext(cc, getAllTracks)) apiGroup.GET("/streams", func(c *gin.Context) { diff --git a/internal/api/video_source.go b/internal/api/video_source.go index 8e0755f..e6be4b5 100644 --- a/internal/api/video_source.go +++ b/internal/api/video_source.go @@ -2,6 +2,7 @@ package api import ( "net/http" + "strconv" "github.com/gin-gonic/gin" "github.com/tellytv/telly/internal/context" @@ -63,10 +64,49 @@ func addVideoSource(cc *context.CContext, c *gin.Context) { } newProvider.Tracks = append(newProvider.Tracks, *newTrack) } - c.JSON(http.StatusOK, newProvider) + c.JSON(http.StatusCreated, newProvider) } } +func saveVideoSource(cc *context.CContext, c *gin.Context) { + videoSourceID := c.Param("sourceId") + + iVideoSourceID, err := strconv.ParseInt(videoSourceID, 0, 32) + if err != nil { + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + var payload models.VideoSource + if c.BindJSON(&payload) == nil { + provider, providerErr := cc.API.VideoSource.UpdateVideoSource(int(iVideoSourceID), payload) + if providerErr != nil { + c.AbortWithError(http.StatusInternalServerError, providerErr) + return + } + + c.JSON(http.StatusOK, provider) + } +} + +func deleteVideoSource(cc *context.CContext, c *gin.Context) { + videoSourceID := c.Param("sourceId") + + iVideoSourceID, err := strconv.ParseInt(videoSourceID, 0, 32) + if err != nil { + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + err = cc.API.VideoSource.DeleteVideoSource(int(iVideoSourceID)) + if err != nil { + c.AbortWithError(http.StatusInternalServerError, err) + return + } + + c.Status(http.StatusNoContent) +} + func getAllTracks(cc *context.CContext, c *gin.Context) { sources, sourcesErr := cc.API.VideoSource.GetAllVideoSources(true) if sourcesErr != nil { diff --git a/internal/commands/guide_updates.go b/internal/commands/guide_updates.go index a0424fc..5bc9937 100644 --- a/internal/commands/guide_updates.go +++ b/internal/commands/guide_updates.go @@ -49,7 +49,7 @@ func fireGuideUpdates(cc *context.CContext, provider *models.GuideSource) error return fmt.Errorf("error when refreshing for provider %s (%s): %s", provider.Name, provider.Provider, reloadErr) } - if updateErr := cc.API.GuideSource.UpdateGuideSource(provider.ID, lineupMetadata); updateErr != nil { + if updateErr := cc.API.GuideSource.UpdateProviderData(provider.ID, lineupMetadata); updateErr != nil { return fmt.Errorf("error when updating guide source provider metadata: %s", updateErr) } diff --git a/internal/models/guide_source.go b/internal/models/guide_source.go index fdd43e0..3bc3e1b 100644 --- a/internal/models/guide_source.go +++ b/internal/models/guide_source.go @@ -60,8 +60,9 @@ func (g *GuideSource) ProviderConfiguration() *guideproviders.Configuration { // GuideSourceAPI contains all methods for the User struct type GuideSourceAPI interface { InsertGuideSource(guideSourceStruct GuideSource, providerData interface{}) (*GuideSource, error) - DeleteGuideSource(guideSourceID int) (*GuideSource, error) - UpdateGuideSource(guideSourceID int, providerData interface{}) error + DeleteGuideSource(guideSourceID int) error + UpdateGuideSource(guideSourceID int, guideSourceStruct GuideSource) (*GuideSource, error) + UpdateProviderData(guideSourceID int, providerData interface{}) error GetGuideSourceByID(id int) (*GuideSource, error) GetAllGuideSources(includeChannels bool) ([]GuideSource, error) GetGuideSourcesForLineup(lineupID int) ([]GuideSource, error) @@ -123,14 +124,29 @@ func (db *GuideSourceDB) GetGuideSourceByID(id int) (*GuideSource, error) { } // DeleteGuideSource marks a guideSource with the given ID as deleted. -func (db *GuideSourceDB) DeleteGuideSource(guideSourceID int) (*GuideSource, error) { - guideSource := GuideSource{} - err := db.SQL.Get(&guideSource, `DELETE FROM guide_source WHERE id = $1`, guideSourceID) - return &guideSource, err +func (db *GuideSourceDB) DeleteGuideSource(guideSourceID int) error { + _, err := db.SQL.Exec(`DELETE FROM guide_source WHERE id = $1`, guideSourceID) + return err } // UpdateGuideSource updates a guideSource. -func (db *GuideSourceDB) UpdateGuideSource(guideSourceID int, providerData interface{}) error { +func (db *GuideSourceDB) UpdateGuideSource(guideSourceID int, guideSourceStruct GuideSource) (*GuideSource, error) { + guideSourceStruct.ID = guideSourceID + + _, err := db.SQL.NamedQuery(` + UPDATE guide_source + SET name = :name, provider = :provider, username = :username, password = :password, + xmltv_url = :xmltv_url, update_frequency = :update_frequency + WHERE id = :id`, guideSourceStruct) + if err != nil { + return nil, err + } + + return &guideSourceStruct, nil +} + +// UpdateProviderData updates provider_data. +func (db *GuideSourceDB) UpdateProviderData(guideSourceID int, providerData interface{}) error { _, err := db.SQL.Exec(`UPDATE guide_source SET provider_data = ? WHERE id = ?`, providerData, guideSourceID) return err } diff --git a/internal/models/video_source.go b/internal/models/video_source.go index 9f92168..db47bca 100644 --- a/internal/models/video_source.go +++ b/internal/models/video_source.go @@ -60,8 +60,8 @@ func (v *VideoSource) ProviderConfiguration() *videoproviders.Configuration { // VideoSourceAPI contains all methods for the User struct type VideoSourceAPI interface { InsertVideoSource(videoSourceStruct VideoSource) (*VideoSource, error) - DeleteVideoSource(videoSourceID int) (*VideoSource, error) - UpdateVideoSource(videoSourceID int, description string) (*VideoSource, error) + DeleteVideoSource(videoSourceID int) error + UpdateVideoSource(videoSourceID int, videoSourceStruct VideoSource) (*VideoSource, error) GetVideoSourceByID(id int) (*VideoSource, error) GetAllVideoSources(includeTracks bool) ([]VideoSource, error) } @@ -116,17 +116,25 @@ func (db *VideoSourceDB) GetVideoSourceByID(id int) (*VideoSource, error) { } // DeleteVideoSource marks a videoSource with the given ID as deleted. -func (db *VideoSourceDB) DeleteVideoSource(videoSourceID int) (*VideoSource, error) { - videoSource := VideoSource{} - err := db.SQL.Get(&videoSource, `DELETE FROM video_source WHERE id = $1`, videoSourceID) - return &videoSource, err +func (db *VideoSourceDB) DeleteVideoSource(videoSourceID int) error { + _, err := db.SQL.Exec(`DELETE FROM video_source WHERE id = $1`, videoSourceID) + return err } // UpdateVideoSource updates a videoSource. -func (db *VideoSourceDB) UpdateVideoSource(videoSourceID int, description string) (*VideoSource, error) { - videoSource := VideoSource{} - err := db.SQL.Get(&videoSource, `UPDATE video_source SET description = $2 WHERE id = $1 RETURNING *`, videoSourceID, description) - return &videoSource, err +func (db *VideoSourceDB) UpdateVideoSource(videoSourceID int, videoSourceStruct VideoSource) (*VideoSource, error) { + videoSourceStruct.ID = videoSourceID + + _, err := db.SQL.NamedQuery(` + UPDATE video_source + SET name = :name, provider = :provider, username = :username, password = :password, + base_url = :base_url, m3u_url = :m3u_url, max_streams = :max_streams, update_frequency = :update_frequency + WHERE id = :id`, videoSourceStruct) + if err != nil { + return nil, err + } + + return &videoSourceStruct, nil } // GetAllVideoSources returns all video sources in the database. From cdf9f93047467cdc972367627989958a065f3480 Mon Sep 17 00:00:00 2001 From: Matt Stevens Date: Tue, 11 Jun 2019 00:42:07 +0100 Subject: [PATCH 181/182] TNG: Lint fixes, go mod tidy, update frontend submodule (#255) * go mod tidy * fix linting errors; disable unparam; errcheck ignore fmt:.*,AbortWithError * update to latest frontend changes --- .golangci.yml | 5 ++++- frontend | 2 +- go.mod | 12 +++++------ go.sum | 24 ++++++++++++++++----- internal/context/context.go | 2 +- internal/guideproviders/schedules_direct.go | 2 +- internal/streamsuite/transports.go | 2 +- 7 files changed, 32 insertions(+), 17 deletions(-) diff --git a/.golangci.yml b/.golangci.yml index 2b6f956..bf28f12 100644 --- a/.golangci.yml +++ b/.golangci.yml @@ -1,8 +1,11 @@ linters-settings: goimports: local-prefixes: github.com/telly/telly + errcheck: + ignore: fmt:.*,AbortWithError linters: + enable-all: false enable: - deadcode - errcheck @@ -19,12 +22,12 @@ linters: - nakedret - structcheck - unconvert - - unparam - varcheck - vet - vetshadow disable: - unused + - unparam run: skip-files: diff --git a/frontend b/frontend index 902a435..053f7ef 160000 --- a/frontend +++ b/frontend @@ -1 +1 @@ -Subproject commit 902a435bbb7d64e46c2e360c16dfc8da37909c28 +Subproject commit 053f7ef37e81e8a20a13c63be1353f42b4a0a476 diff --git a/go.mod b/go.mod index 18b825a..876ae32 100644 --- a/go.mod +++ b/go.mod @@ -24,9 +24,8 @@ require ( github.com/onsi/ginkgo v1.8.0 // indirect github.com/onsi/gomega v1.5.0 // indirect github.com/pelletier/go-toml v1.4.0 // indirect - github.com/prometheus/client_golang v0.9.3 + github.com/prometheus/client_golang v0.9.4 github.com/prometheus/common v0.4.1 - github.com/prometheus/procfs v0.0.2 // indirect github.com/robfig/cron v1.1.0 github.com/rubenv/sql-migrate v0.0.0-20190327083759-54bad0a9b051 github.com/schollz/closestmatch v2.1.0+incompatible @@ -37,13 +36,12 @@ require ( github.com/spf13/viper v1.4.0 github.com/tellytv/go.schedulesdirect v0.0.0-20180903021109-bb2d9eec79e9 github.com/tellytv/go.xtream-codes v0.0.0-20190427212115-45e8162ba888 - github.com/ugorji/go v1.1.5-pre // indirect + github.com/ugorji/go/codec v1.1.5-pre // indirect github.com/ziutek/mymysql v1.5.4 // indirect github.com/zsais/go-gin-prometheus v0.0.0-20181030200533-58963fb32f54 gitlab.com/NebulousLabs/go-upnp v0.0.0-20181011194642-3a71999ed0d3 // indirect - golang.org/x/net v0.0.0-20190603091049-60506f45cf65 - golang.org/x/sys v0.0.0-20190606122018-79a91cf218c4 // indirect - golang.org/x/text v0.3.2 // indirect - google.golang.org/appengine v1.6.0 // indirect + golang.org/x/net v0.0.0-20190607175257-26fcbda1b1be + golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444 // indirect + google.golang.org/appengine v1.6.1 // indirect gopkg.in/gorp.v1 v1.7.2 // indirect ) diff --git a/go.sum b/go.sum index 6a0be3c..a2dd9a0 100644 --- a/go.sum +++ b/go.sum @@ -73,6 +73,7 @@ github.com/gobuffalo/syncx v0.0.0-20190224160051-33c29581e754/go.mod h1:HhnNqWY9 github.com/gofrs/uuid v3.2.0+incompatible h1:y12jRkkFxsd7GpqdSZ+/KCs/fJbqpEXSGd4+jfEaewE= github.com/gofrs/uuid v3.2.0+incompatible/go.mod h1:b2aQJv3Z4Fp6yNu3cdSllBxTCLRxnplIgP/c0N/04lM= github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ= +github.com/gogo/protobuf v1.2.1 h1:/s5zKNz0uPFCZ5hddgPdo2TK2TVrUNMn0OOX8/aZMTE= github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4= github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q= github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= @@ -90,6 +91,7 @@ github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4= github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ= github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI= github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU= +github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM= github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8= github.com/jmoiron/sqlx v1.2.0 h1:41Ip0zITnmWNR/vHV+S4m+VoUivnWY5E4OJfLZjCJMA= github.com/jmoiron/sqlx v1.2.0/go.mod h1:1FEQNm3xlJgrMD+FBdI9+xvCksHtbpVBBw5dYhBSsks= @@ -101,6 +103,7 @@ github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCV github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= github.com/karrick/godirwalk v1.8.0/go.mod h1:H5KPZjojv4lE+QYImBI8xVtrBRgYrIVsaRPx4tDPEn4= github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q= +github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= github.com/konsorten/go-windows-terminal-sequences v1.0.2 h1:DB17ag19krx9CFsz4o3enTrPXyIXCl+2iCXH/aMAp9s= @@ -164,6 +167,8 @@ github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZN github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw= github.com/prometheus/client_golang v0.9.3 h1:9iH4JKXLzFbOAdtqv/a+j8aewx2Y8lAjAydhbaScPF8= github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso= +github.com/prometheus/client_golang v0.9.4 h1:Y8E/JaaPbmFSW2V81Ab/d8yZFYQQGbni1b1jPcG9Y6A= +github.com/prometheus/client_golang v0.9.4/go.mod h1:oCXIBxdI62A4cR6aTRJCgetEjecSIYzOEaeAn4iYEpM= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910 h1:idejC8f05m9MGOsuEi1ATq9shN03HrxNkD/luQvxCv8= github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo= github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90 h1:S/YWwWx/RA8rT8tKFRuGUZhuA90OyIBpPCXkcbwU8DE= @@ -240,25 +245,31 @@ go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/ go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q= golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5 h1:58fnuSXlxZmFdJyvtTFVmVhcMLU6v5fEb/ok4wyqtNU= +golang.org/x/crypto v0.0.0-20190605123033-f99c8df09eb5/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE= golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc= -golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4= golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= +golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c h1:uOCk1iQW6Vc18bnC13MfzScl+wdKBmM9Y9kU7Z83/lw= golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= golang.org/x/net v0.0.0-20190603091049-60506f45cf65 h1:+rhAzEzT3f4JtomfC371qB+0Ola2caSKcY69NUBZrRQ= golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks= +golang.org/x/net v0.0.0-20190607175257-26fcbda1b1be h1:Vb7KUggkvLRs0EQYvRuP3FunY+I4dwMGbYWD3Y4p+tg= +golang.org/x/net v0.0.0-20190607175257-26fcbda1b1be/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U= golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190412183630-56d357773e84/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= +golang.org/x/sync v0.0.0-20190423024810-112230192c58 h1:8gQV6CLnAEikrhgkHFbMAEhagSSnXWGV915qUMm9mrU= +golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= @@ -266,10 +277,12 @@ golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5h golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= +golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= -golang.org/x/sys v0.0.0-20190606122018-79a91cf218c4 h1:3i7qG/aA9NUAzdnJHfhgxSKSmxbAebomYR5IZgFbC5Y= -golang.org/x/sys v0.0.0-20190606122018-79a91cf218c4/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606165138-5da285871e9c/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= +golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444 h1:/d2cWp6PSamH4jDPFLyO150psQdqvtoNX8Zjg3AQ31g= +golang.org/x/sys v0.0.0-20190606203320-7fc4e5ec1444/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs= @@ -281,9 +294,10 @@ golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGm golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190329151228-23e29df326fe/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= golang.org/x/tools v0.0.0-20190404132500-923d25813098/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs= +golang.org/x/tools v0.0.0-20190606124116-d0a3d012864b/go.mod h1:/rFqwRUd4F7ZHNgwSSTFct+R/Kf4OFW1sUzUTQQTgfc= google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM= -google.golang.org/appengine v1.6.0 h1:Tfd7cKwKbFRsI8RMAD3oqqw7JPFRrvFlOsfbgVkjOOw= -google.golang.org/appengine v1.6.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4= +google.golang.org/appengine v1.6.1 h1:QzqyMA1tlu6CgqCDUtU9V+ZKhLFT2dkJuANu5QaxI3I= +google.golang.org/appengine v1.6.1/go.mod h1:i06prIuMbXzDqacNJfV5OdTW448YApPu5ww/cMBSeb0= google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc= google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c= google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM= diff --git a/internal/context/context.go b/internal/context/context.go index 4049f56..a700d56 100644 --- a/internal/context/context.go +++ b/internal/context/context.go @@ -8,7 +8,7 @@ import ( "github.com/gobuffalo/packr" "github.com/jmoiron/sqlx" _ "github.com/mattn/go-sqlite3" // the SQLite driver - "github.com/rubenv/sql-migrate" + migrate "github.com/rubenv/sql-migrate" "github.com/sirupsen/logrus" "github.com/spf13/viper" "github.com/tellytv/telly/internal/guideproviders" diff --git a/internal/guideproviders/schedules_direct.go b/internal/guideproviders/schedules_direct.go index 278e306..f5d2f85 100644 --- a/internal/guideproviders/schedules_direct.go +++ b/internal/guideproviders/schedules_direct.go @@ -9,7 +9,7 @@ import ( "strings" "time" - "github.com/tellytv/go.schedulesdirect" + schedulesdirect "github.com/tellytv/go.schedulesdirect" "github.com/tellytv/telly/internal/utils" "github.com/tellytv/telly/internal/xmltv" ) diff --git a/internal/streamsuite/transports.go b/internal/streamsuite/transports.go index 2ae6c60..566fe18 100644 --- a/internal/streamsuite/transports.go +++ b/internal/streamsuite/transports.go @@ -122,7 +122,7 @@ type httpError struct { Contents string } -func newHTTPError(err error, code int, reader io.ReadCloser) httpError { +func newHTTPError(err error, code int, reader io.Reader) httpError { buf := &bytes.Buffer{} if reader != nil { if _, copyErr := io.Copy(buf, reader); copyErr != nil { From c56e5888fe2b83ce9f1117eabffa777f9343cb68 Mon Sep 17 00:00:00 2001 From: Charles Larson Date: Fri, 3 Jul 2020 21:04:30 -0500 Subject: [PATCH 182/182] update go.mod --- go.mod | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/go.mod b/go.mod index 876ae32..7f76ddc 100644 --- a/go.mod +++ b/go.mod @@ -8,6 +8,7 @@ require ( github.com/gin-contrib/cors v1.3.0 github.com/gin-contrib/sse v0.1.0 // indirect github.com/gin-gonic/gin v1.4.0 + github.com/go-logfmt/logfmt v0.4.0 // indirect github.com/go-sql-driver/mysql v1.4.1 // indirect github.com/gobuffalo/packd v0.1.0 // indirect github.com/gobuffalo/packr v1.25.0 @@ -36,7 +37,7 @@ require ( github.com/spf13/viper v1.4.0 github.com/tellytv/go.schedulesdirect v0.0.0-20180903021109-bb2d9eec79e9 github.com/tellytv/go.xtream-codes v0.0.0-20190427212115-45e8162ba888 - github.com/ugorji/go/codec v1.1.5-pre // indirect + github.com/ugorji/go v1.1.5-pre // indirect github.com/ziutek/mymysql v1.5.4 // indirect github.com/zsais/go-gin-prometheus v0.0.0-20181030200533-58963fb32f54 gitlab.com/NebulousLabs/go-upnp v0.0.0-20181011194642-3a71999ed0d3 // indirect