Exemplo n.º 1
0
        public virtual TrackCollection <ITrack> LoadTracks(ChannelData.TRACKSRow tracksRow, bool bypassCache,
                                                           ref string siteName, IChannel channel)
        {
            // check if channel already has a tracks collection, if not create a blank one
            var tracks = new TrackCollection <ITrack>();

            if (channel.Tracks != null)
            {
                tracks.AddRange(channel.Tracks.ToArray()); // add the existing array of tracks
            }
            _tracksQueue = new ConcurrentQueue <TTrack>();

            // foreach (ChannelData.TRACKRow tr in tracksRow.GetTRACKRows()) _tracksQueue.Enqueue(tr as TTrack);


            // _tracksQueue = new ConcurrentQueue<TTrack>();


            foreach (var trackRow in tracksRow.GetTRACKRows())
            {
                _track =
                    tracks.Find(
                        t =>
                        t.Name.Equals(trackRow.TRACKTITLE.Replace(" ", ""), StringComparison.CurrentCultureIgnoreCase))
                    as TTrack;

                // extract the site name from the forum url. the playlist doesn't have the site url in the schema
                if (!trackRow.IsTRACKURLNull())
                {
                    if (trackRow.TRACKURL.Contains(P.Resources.SkyHomePage))
                    {
                        siteName = string.Format(siteName, P.Resources.SkyHomePage);
                    }
                    if (trackRow.TRACKURL.Contains(P.Resources.DIHomePage))
                    {
                        siteName = string.Format(siteName, P.Resources.DIHomePage);
                    }
                }

                // track exists, update track info which is updateable...comment count is
                if (tracks.Contains(_track))
                {
                    if (_track != null)
                    {
                        _track.CommentCount = int.Parse(trackRow.BOARDCOUNT);
                    }
                }
                else
                {
                    _track = new TTrack {
                        ParentChannel = channel
                    };

                    // load up the tracks collection for the channel
                    if (!trackRow.IsSTARTTIMENull())
                    {
                        var epoch = new DateTime(1970, 1, 1, 0, 0, 0, 0);
                        _track.StartTime = epoch.AddSeconds(double.Parse(trackRow.STARTTIME)).ToLocalTime();
                    }
                    if (!trackRow.IsTRACKTITLENull())
                    {
                        _track.TrackTitle = trackRow.TRACKTITLE;
                    }

                    if (!trackRow.IsBOARDCOUNTNull())
                    {
                        _track.CommentCount = int.Parse(trackRow.BOARDCOUNT);
                    }

                    if (!trackRow.IsTRACKURLNull())
                    {
                        if (Uri.IsWellFormedUriString(trackRow.TRACKURL, UriKind.Absolute))
                        {
                            _track.ForumUrl = new Uri(trackRow.TRACKURL);
                        }
                    }

                    if (!trackRow.IsLABELNull())
                    {
                        _track.RecordLabel = trackRow.LABEL;
                    }

                    foreach (var extraUrlRow in trackRow.GetEXTRAURLRows().Where(extraUrlRow => !extraUrlRow.IsEXTRAURL_TextNull()).Where(extraUrlRow => Uri.IsWellFormedUriString(extraUrlRow.EXTRAURL_Text, UriKind.Absolute)))
                    {
                        _track.ArtistUri = new Uri(extraUrlRow.EXTRAURL_Text);
                    }

                    _tracksQueue.Enqueue(_track);
                }
            }

            if (_tracksQueue.Count > 0)
            {
                tracks.InsertRange(0, _tracksQueue.ToArray()); // insert the new tracks
                // tracks.HasNewTracks = true;
            }

            if (tracks.Count > tracksRow.GetTRACKRows().Length)
            {
                tracks.RemoveRange(tracksRow.GetTRACKRows().Length, tracks.Count - tracksRow.GetTRACKRows().Length);
            }

            return(tracks);
        }
Exemplo n.º 2
0
        /// <summary>
        ///   Method to get an array of DI Channels.
        /// </summary>
        /// <param name="bypassCache"> Specifies whether the collection should be retrieved from the cache. </param>
        /// <returns> An array of DI Channel controls. </returns>
        public virtual ChannelCollection <TChannel> LoadChannels(bool bypassCache)
        {
            var channels = new ChannelCollection <TChannel>();

            if (_channels != null)
            {
                _channels.ForEach(t => channels.Add(t));
            }

            if ((bypassCache) || (channels.Count == 0))
            {
                channels = new ChannelCollection <TChannel>();
            }

            _channelData = LoadPlaylist(false) as ChannelData;

            if (_channelData != null)
            {
                _channelArray = new List <TChannel>(_channelData.Tables["CHANNEL"].Rows.Count);
            }

            int i = 0;

            // Parallel.ForEach(_channelData.Tables["CHANNEL"].Rows.Cast<ChannelData.CHANNELRow>(), rowItem =>

            if (_channelData != null)
            {
                foreach (ChannelData.CHANNELRow rowItem in _channelData.Tables["CHANNEL"].Rows)
                {
                    ChannelData.CHANNELRow item = rowItem;
                    _channel =
                        channels.Find(
                            t =>
                            t.Name.Equals(item.CHANNELTITLE.Replace(" ", ""), StringComparison.CurrentCultureIgnoreCase)) ??
                        new TChannel();

                    string siteName = Resources.Properties.Resources.UrlContainer;
                    _channel.ChannelName = Utilities.SplitName(rowItem.CHANNELTITLE);


                    // Parallel.ForEach(rowItem.GetTRACKSRows().Cast<ChannelData.TRACKRow>(), tracksRow =>

                    foreach (var tracksRow in rowItem.GetTRACKSRows())
                    {
                        ChannelData.TRACKSRow tr = tracksRow;

                        _channel.Tracks = _trackLoader.LoadTracks(tr, false, ref siteName, _channel);
                    }

                    if (rowItem.CHANNELTITLE != null)
                    {
                        _channel.SiteName = siteName;
                        string channelUrl = string.Format("{0}{1}", siteName, rowItem.CHANNELTITLE.ToLower().Trim());

                        try
                        {
                            _channel.PlaylistHistoryUrl = new Uri(channelUrl);
                            _channel.ChannelInfoUrl     = new Uri(string.Format("{0}", channelUrl));

                            _channelArray.Insert(i, _channel);
                            i++;
                        }
                        catch (UriFormatException)
                        {
                            _channel.PlaylistHistoryUrl = new Uri("http://www.google.com");
                            _channel.ChannelInfoUrl     = new Uri("http://www.google.com");
                        }
                    }
                }
            }

            channels.Clear();
            channels.AddRange(_channelArray);

            if (_channels == null)
            {
                _channels = new ChannelCollection <TChannel>();
            }

            _channels.Clear();
            channels.Clone(_channels);

            return(channels);
        }