protected SSHChannel(SSHConnection con, ChannelType type, int localID)
 {
     con.ChannelCollection.RegisterChannel(localID, this);
     _connection = con;
     _type = type;
     _localID = localID;
 }

 public Dictionary<string, string> GetLogos(List<string> channelsNames, ChannelType type, string regionCode)
 {
     var result = new Dictionary<string, string>();
     using (var ctx = new EF.RepositoryContext("LogoDB"))
     {
         foreach (var channelName in channelsNames)
         {
             var aliases = ctx.Aliases.Include("Channel").Include("Channel.Logos").Include("Channel.Logos.Suggestion").Where(a => a.Name == channelName && a.Channel.Type == type);
             if (aliases.Any())
             {
                 if (!string.IsNullOrWhiteSpace(regionCode))
                 {
                     // find best matching by RegionCode
                     var matchedByRegion = aliases.FirstOrDefault(a => a.Channel.RegionCode == regionCode);
                     if (matchedByRegion != null)
                     {
                         result.Add(channelName, matchedByRegion.Channel.Logos.First(l => l.Suggestion == null).Id.ToString());
                         continue;
                     }
                 }
                 // simply use first one
                 result.Add(channelName, aliases.First().Channel.Logos.First(l => l.Suggestion == null).Id.ToString());
             }
         }
     }
     return result;
 }

    /// <summary>
    /// Play the specified audioClip on specified channel type. This function is meant to be used for single sound occurences.
    /// Use default level will set the attenuation to its default level.
    /// </summary>
    /// <param name="audioClip">Audio clip.</param>
    /// <param name="clipName">Clip name.</param>
    /// <param name="channeltype">Channeltype.</param>
    public void Play(AudioClip audioClip, ChannelType channeltype, AudioClipInfo clipInfo)
    {
        GameObject go = new GameObject("GameSound");
        go.tag = channeltype.ToString();
        go.transform.SetParent(gameObject.transform, false);
        AudioSource source = go.AddComponent<AudioSource>();
        source.playOnAwake = false;

        source.clip = audioClip;

        float lvl = 0.0f;
        ChannelInfo chInfo = null;
        channelInfos.TryGetValue(channeltype.ToString(), out chInfo);

        if(chInfo != null)
        {
            lvl = clipInfo.useDefaultDBLevel ? chInfo.defaultDBLevel : chInfo.settedDBLevel;
        }
        else
        {
            Debug.LogError("Channel info not found");
        }

        audioMixer.SetFloat(channeltype.ToString(),lvl);
        source.outputAudioMixerGroup = chInfo.audioMixerGroup;

        source.loop = clipInfo.isLoop;

        source.PlayDelayed(clipInfo.delayAtStart);
        playingList.Add(go);
    }

 public Channel(ChannelType type, int width, int height, long size)
 {
     this.type = type;
     this.width = width;
     this.height = height;
     this.size = size;
 }

        /// <summary>
        /// Constructor (initiated by server)
        /// </summary>
        public SSH2ChannelBase(
                IPacketSender<SSH2Packet> packetSender,
                SSHConnectionParameter param,
                SSHProtocolEventManager protocolEventManager,
                uint localChannel,
                uint remoteChannel,
                ChannelType channelType,
                string channelTypeString,
                uint serverWindowSize,
                uint serverMaxPacketSize)
        {
            _packetSender = packetSender;
            _protocolEventManager = protocolEventManager;
            LocalChannel = localChannel;
            RemoteChannel = remoteChannel;
            ChannelType = channelType;
            ChannelTypeString = channelTypeString;

            _localMaxPacketSize = param.MaxPacketSize;
            _localWindowSize = _localWindowSizeLeft = param.WindowSize;
            _serverMaxPacketSize = serverMaxPacketSize;
            _serverWindowSizeLeft = serverWindowSize;

            _state = State.InitiatedByServer; // SendOpenConfirmation() will change state to "Opened"
        }

        /// <summary>
        /// Setup constructor
		/// </summary>
		/// <param name="policyType">Associated policy type</param>
        /// <param name="name">Policy type display name</param>
        /// <param name="channels">Policy type channels</param>
        /// <param name="available">If policy type is available to be used in the designer</param>
		public PolicyTypeInfo(PolicyType policyType, IPolicyLanguageItem name, ChannelType[] channels, bool available)
		{
			m_PolicyType = policyType;
            m_Name = name;
            m_Channels = channels;
            m_Available = available;
        }

 protected SSHChannel(SSHConnection con, ChannelType type, int local_id)
 {
     con.RegisterChannel(local_id, this);
     _connection = con;
     _type = type;
     _localID = local_id;
 }

 public void Initialize(ChannelType channelType, int epgHours, int epgHoursOffset, string allChannelsGroupName)
 {
     _model.EpgHours = epgHours;
     _model.EpgHoursOffset = epgHoursOffset;
     _model.AllChannelsGroupName = allChannelsGroupName;
     ChangeChannelType(channelType);
 }

        public static DoubleMatrix GetChannel(this MatrixBase<YCbCrColor> matrix,  ChannelType channelType)
        {
            var ret = new DoubleMatrix(matrix.RowCount, matrix.ColumnCount);

            for (int i = 0; i < matrix.RowCount; i++)
            {
                for (int j = 0; j < matrix.ColumnCount; j++)
                {
                    switch (channelType)
                    {
                        case ChannelType.Y:
                            ret[i, j] = matrix[i, j].Y;
                            break;
                        case ChannelType.Cr:
                            ret[i, j] = matrix[i, j].Cr;
                            break;
                        case ChannelType.Cb:
                            ret[i, j] = matrix[i, j].Cb;
                            break;
                        default:
                            throw new ArgumentOutOfRangeException("channelType");
                    }
                }
            }

            return ret;
        }

        public void ChangeChannelType(ChannelType channelType)
        {
            _model.ChannelType = channelType;
            _model.ChannelGroups.Clear();
            _model.ChannelGroups.AddRange(Proxies.SchedulerService.GetAllChannelGroups(channelType, true).Result);
            _model.ChannelGroups.Add(new ChannelGroup()
            {
                ChannelGroupId = channelType == ChannelType.Television ? ChannelGroup.AllTvChannelsGroupId : ChannelGroup.AllRadioChannelsGroupId,
                ChannelType = channelType,
                GroupName = _model.AllChannelsGroupName,
                VisibleInGuide = true
            });

            if (_model.GuideDateTime == DateTime.MinValue)
            {
                GotoNow();
                _model.CurrentChannelGroupId = _model.ChannelGroups[0].ChannelGroupId;
            }
            else
            {
                bool currentIsOk = false;
                foreach (ChannelGroup channelGroup in _model.ChannelGroups)
                {
                    if (channelGroup.ChannelGroupId == _model.CurrentChannelGroupId)
                    {
                        currentIsOk = true;
                        break;
                    }
                }
                if (!currentIsOk)
                {
                    _model.CurrentChannelGroupId = _model.ChannelGroups[0].ChannelGroupId;
                }
            }
        }

 /// <summary>
 /// </summary>
 /// <param name="flags">
 /// </param>
 /// <param name="type">
 /// </param>
 /// <param name="id">
 /// </param>
 /// <param name="name">
 /// </param>
 public ChannelBase(ChannelFlags flags, ChannelType type, uint id, string name = "")
 {
     this.channelFlags = flags;
     this.channelType = type;
     this.ChannelId = id;
     this.ChannelName = name;
 }

        public ImportChannelsContext(ChannelType channelType)
        {
            _channelType = channelType;

            List<TreeNode> nodes = new List<TreeNode>();

            if (channelType == ChannelType.Television)
            {
                List<TvDatabase.ChannelGroup> groups = Utility.GetAllGroups<TvDatabase.ChannelGroup>();
                groups.Add(new TvDatabase.ChannelGroup(-1, "All Channels"));
                foreach (TvDatabase.ChannelGroup group in groups)
                {
                    TreeNode groupNode = new TreeNode(group.GroupName);
                    groupNode.Tag = group;
                    nodes.Add(groupNode);
                    groupNode.Nodes.Add(String.Empty);
                }
            }
            else
            {
                List<TvDatabase.RadioChannelGroup> groups = Utility.GetAllGroups<TvDatabase.RadioChannelGroup>();
                groups.Add(new TvDatabase.RadioChannelGroup(-1, "All Channels"));
                foreach (TvDatabase.RadioChannelGroup group in groups)
                {
                    TreeNode groupNode = new TreeNode(group.GroupName);
                    groupNode.Tag = group;
                    nodes.Add(groupNode);
                    groupNode.Nodes.Add(String.Empty);
                }
            }

            _channelNodes = nodes.ToArray();
        }

        private static GatewayRef StartGateway(ActorSystem system, ChannelType type, int port)
        {
            var serializer = PacketSerializer.CreatePacketSerializer();

            var initiator = new GatewayInitiator
            {
                ListenEndPoint = new IPEndPoint(IPAddress.Any, port),
                GatewayLogger = LogManager.GetLogger("Gateway"),
                CreateChannelLogger = (ep, _) => LogManager.GetLogger($"Channel({ep}"),
                ConnectionSettings = new TcpConnectionSettings { PacketSerializer = serializer },
                PacketSerializer = serializer,
                CreateInitialActors = (context, connection) => new[]
                {
                    Tuple.Create(context.ActorOf(Props.Create(() => new EntryActor(context.Self.Cast<ActorBoundChannelRef>()))),
                                 new TaggedType[] { typeof(IEntry) },
                                 (ActorBindingFlags)0)
                }
            };

            var gateway = (type == ChannelType.Tcp)
                ? system.ActorOf(Props.Create(() => new TcpGateway(initiator))).Cast<GatewayRef>()
                : system.ActorOf(Props.Create(() => new UdpGateway(initiator))).Cast<GatewayRef>();
            gateway.Start().Wait();
            return gateway;
        }

        public static Server.GatewayRef CreateGateway(ActorSystem system, ChannelType type, string name, IPEndPoint endPoint,
                                                      XunitOutputLogger.Source outputSource,
                                                      Action<Server.GatewayInitiator> clientInitiatorSetup = null)
        {
            // initialize gateway initiator

            var initiator = new Server.GatewayInitiator()
            {
                GatewayLogger = new XunitOutputLogger($"Gateway({name})", outputSource),
                ListenEndPoint = endPoint,
                ConnectEndPoint = endPoint,
                TokenRequired = false,
                CreateChannelLogger = (_, o) => new XunitOutputLogger($"ServerChannel({name})", outputSource),
                CheckCreateChannel = (_, o) => true,
                ConnectionSettings = new Server.TcpConnectionSettings { PacketSerializer = s_serverSerializer },
                PacketSerializer = s_serverSerializer,
            };

            clientInitiatorSetup?.Invoke(initiator);

            // create gateway and start it

            var gateway = (type == ChannelType.Tcp)
                ? system.ActorOf(Props.Create(() => new Server.TcpGateway(initiator))).Cast<Server.GatewayRef>()
                : system.ActorOf(Props.Create(() => new Server.UdpGateway(initiator))).Cast<Server.GatewayRef>();
            gateway.Start().Wait();

            return gateway;
        }

 /// <summary>
 /// Erzeugt eine Instanz von der Klasse Event.
 /// </summary>
 /// <param name="id">Die eindeutige Id des Events.</param>
 /// <param name="name">Der Name des Events.</param>
 /// <param name="description">Die Beschreibung des Events.</param>
 /// <param name="type">Der Typ des Kanals, hier Event.</param>
 /// <param name="creationDate">Das Erstellungsdatum des Events.</param>
 /// <param name="modiciationDate">Das Datum der letzten Änderung.</param>
 /// <param name="term">Das zugeordnete Semester.</param>
 /// <param name="locations">Ort, an dem das Event stattfindet.</param>
 /// <param name="dates">Termin, an dem das Event stattfindet.</param>
 /// <param name="contacts">Kontaktdaten von verantwortlichen Personen.</param>
 /// <param name="website">Ein oder mehrere Links auf Webseiten.</param>
 /// <param name="deleted">Gibt an, ob das Event als gelöscht markiert wurde.</param>
 /// <param name="cost">Die dem Event zugeordneten Kosten.</param>
 /// <param name="organizer">Der Veranstalter des Events.</param>
 public Event(int id, string name, string description, ChannelType type, DateTimeOffset creationDate, 
     DateTimeOffset modiciationDate, string term, string locations, string dates, string contacts, 
     string website, bool deleted, string cost, string organizer)
     : base(id, name, description, type, creationDate, modiciationDate, term, locations, dates, contacts, website, deleted)
 {
     this.cost = cost;
     this.organizer = organizer;
 }

        public async Task SlimClientFailedToConnectToSlimServer(ChannelType type)
        {
            // Act
            var exception = await Record.ExceptionAsync(() => CreatePrimaryClientChannelAsync(type));

            // Assert
            Assert.NotNull(exception);
        }

 public ChannelLink(ChannelType channelType, Guid channelId, string channelName, int mpChannelId, string mpChannelName)
 {
     this.ChannelType = channelType;
     this.ChannelId = channelId;
     this.ChannelName = channelName;
     this.MPChannelId = mpChannelId;
     this.MPChannelName = mpChannelName;
 }

 public Sports(int id, string name, string description, ChannelType type, DateTimeOffset creationDate,
     DateTimeOffset modificationDate, string term, string locations, string dates, string contacts, string website,
     bool deleted, string cost, string numberOfParticipants)
     : base(id, name, description, type, creationDate, modificationDate, term, locations, dates, contacts, website, deleted)
 {
     this.cost = cost;
     this.numberOfParticipants = numberOfParticipants;
 }

 public FileTransferChannelInfo(ChannelType type, 
                        HandleType target, 
                        string content_type, 
                        string description)
     : base(type, target)
 {
     ContentType = content_type;
     Description = description;
 }

 public static Schedule CreateRecordOnceSchedule(ChannelType channelType, Guid channelId, Guid guideProgramId)
 {
     GuideProgram guideProgram = Proxies.GuideService.GetProgramById(guideProgramId).Result;
     if (guideProgram != null)
     {
         return CreateRecordOnceSchedule(channelType, channelId, guideProgram.Title, guideProgram.SubTitle, guideProgram.EpisodeNumberDisplay, guideProgram.StartTime);
     }
     return null;
 }