IEnumerable <Channel> GetEnabledChannels(IEnumerable <Channel> filteredProviderChannels)
        {
            ConcurrentBag <Channel>         channels = new ConcurrentBag <Channel>();
            IEnumerable <ChannelDefinition> enabledChannelDefinitions = channelDefinitions
                                                                        .Where(x => x.IsEnabled && groups[x.GroupId].IsEnabled);

            Parallel.ForEach(enabledChannelDefinitions, channelDef =>
            {
                logger.Debug(
                    MyOperation.ChannelMatching,
                    OperationStatus.Started,
                    new LogInfo(MyLogInfoKey.Channel, channelDef.Name.Value));

                List <Channel> matchedChannels = filteredProviderChannels
                                                 .Where(x => channelMatcher.DoesMatch(channelDef.Name, x.Name, x.Country))
                                                 .ToList();

                if (!matchedChannels.Any())
                {
                    return;
                }

                logger.Debug(
                    MyOperation.ChannelMatching,
                    OperationStatus.InProgress,
                    new LogInfo(MyLogInfoKey.Channel, channelDef.Name.Value),
                    new LogInfo(MyLogInfoKey.ChannelsCount, matchedChannels.Count));

                Channel matchedChannel = matchedChannels.FirstOrDefault(x => mediaSourceChecker.IsSourcePlayableAsync(x.Url).Result);

                if (matchedChannel is null)
                {
                    logger.Debug(
                        MyOperation.ChannelMatching,
                        OperationStatus.Failure,
                        new LogInfo(MyLogInfoKey.Channel, channelDef.Name.Value));

                    return;
                }

                Channel channel             = new Channel();
                channel.Id                  = channelDef.Id;
                channel.Name                = channelDef.Name.Value;
                channel.Country             = channelDef.Country;
                channel.Group               = groups[channelDef.GroupId].Name;
                channel.LogoUrl             = channelDef.LogoUrl;
                channel.PlaylistId          = matchedChannel.PlaylistId;
                channel.PlaylistChannelName = matchedChannel.PlaylistChannelName;
                channel.Url                 = matchedChannel.Url;

                channels.Add(channel);

                logger.Debug(
                    MyOperation.ChannelMatching,
                    OperationStatus.Success,
                    new LogInfo(MyLogInfoKey.Channel, channelDef.Name.Value));
            });

            return(channels);
        }
        void AssertThatSourceUrlIsNotPlayable(string sourceUrl)
        {
            // Act
            bool sourceIsPlayale = mediaSourceChecker.IsSourcePlayableAsync(sourceUrl).Result;

            // Assert
            Assert.That(sourceIsPlayale, Is.False);
        }
예제 #3
0
        IEnumerable <Channel> FilterProviderChannels(
            IList <Channel> channels,
            IEnumerable <ChannelDefinition> channelDefinitions)
        {
            logger.Info(
                MyOperation.ProviderChannelsFiltering,
                OperationStatus.Started,
                new LogInfo(MyLogInfoKey.ChannelsCount, channels.Count()));

            List <Task>             tasks            = new List <Task>();
            ConcurrentBag <Channel> filteredChannels = new ConcurrentBag <Channel>();
            IEnumerable <Channel>   uniqueChannels   = channels
                                                       .GroupBy(x => dnsResolver.ResolveUrl(x.Url))
                                                       .Select(g => g.First());

            foreach (Channel channel in uniqueChannels)
            {
                Task task = Task.Run(async() =>
                {
                    bool isPlayable = await mediaSourceChecker.IsSourcePlayableAsync(channel.Url);

                    if (isPlayable)
                    {
                        filteredChannels.Add(channel);
                    }
                });

                tasks.Add(task);
            }

            Task.WaitAll(tasks.ToArray());

            logger.Info(
                MyOperation.ProviderChannelsFiltering,
                OperationStatus.Success);

            return(filteredChannels.OrderBy(x => channels.IndexOf(x)));
        }