protected ConsoleOutputTask(IServer server, IEventAggregator events)
			: base(events)
		{
			this.server = server;
			Console = new BindableCollection<string>();
			server.CurrentDatabaseChanged += delegate { ClearConsole(); };
		}

 public UserQuitEventArgs(IUser user, IChannel channel, IServer server, string reason = null)
 {
     this.User = user;
     this.Channel = channel;
     this.Server = server;
     this.Reason = reason;
 }

 public Account(string username, string passwordHash, ICountry country, IServer server)
 {
     Username = username;
     PasswordHash = passwordHash;
     Country = country;
     Server = server;
 }

 public void AddServer(IServer server)
 {
     TreeIter iter = Store.Append();
     //Store.SetValue(iter, 0, new Gdk.Pixbuf...)
     Store.SetValue(iter, 1, server.Name);
     Store.SetValue(iter, 2, server);
 }

 protected static void RemoveMethodFromNewClientEvent(IServer server, ClientConnectedEventHandler clientConnectedEventHandler)
 {
     lock (clientConnectedEventHandler)
     {
         server.NewClientEvent -= clientConnectedEventHandler;
     }            
 }

 protected static void AddMethodToNewClientEvent(IServer server, ClientConnectedEventHandler clientConnectedEventHandler)
 {
     lock (newClientEventMonitor)
     {
         server.NewClientEvent += clientConnectedEventHandler;
     }            
 }

 public Connector(IServer server, string ip, int port)
 {
     Connections = new List<IWebSocketConnection>();
     _server = server;
     _ip = ip;
     _port = port;
 }

		public PacketManager(TextWriter logger, IServer server)
		{
			Logger = logger;
			Server = server;

			_packetHandlers = new Dictionary<DataIdentifier, Func<EndPoint, ChatPacket, ChatPacket>>();
		}

 public PadInt(int txid, int uid, IServer server, int version)
 {
     _txid = txid;
     _uid = uid;
     _server = server;
     _version = version;
 }

        /// <summary>
        /// Add an socket to "server"-Server-Instance and register it
        /// </summary>
        /// <param name="ep">Socket to register</param>
        /// <param name="server">Server-Instance</param>
        public BaseConnection(Socket client, IServer server)
        {
            if (client == null)
                throw new ArgumentNullException("client");

            if (server == null)
                throw new ArgumentNullException("server");

            //			this._encoding = Encoding.GetEncoding(28591);// iso_8859-1
            this.handler = client;
            this._server = server;
            /*
            int id = this.rnd.Next();
            while (server.HasID(id) || server.SeedID(id)) // new seed id
            {
                id = this.rnd.Next();
            }

            this._id = id;

            #if UNSTABLE
            SocketManager socketManager = ((BaseServer)this._server).SocketManager;
            socketManager.AddConnection(this);
            #else
            ThreadPool.QueueUserWorkItem(new WaitCallback(this.RecieveProc), null); // to/do: 25 Thread Limit!!!!
            #endif

            this.available = true;

            Console.WriteLine("new BaseConnection with id: {0}, is availbale", id);*/
            this.Initialize();
        }

        public void Use(IServer server, string commandName, string[] tokens)
        {
            if (tokens.Length < 1)
            {
                Help(server);
                return;
            }

            var toKick = server.GetClients();


            if (toKick.Any() && tokens[0].ToLower() != "all")
            {
                foreach (var client1 in toKick.Where(client1 => !client1.GetOwner().CanUseCommand("chraft.kick.exempt")))
                {
                    client1.Kick(tokens.Length > 1 ? tokens[1] : "Kicked");
                    server.GetLogger().Log(LogLevel.Info, "Kicked " + client1.GetOwner().Name);
                }
            }
            else
            {
                foreach (IClient t in toKick.Where(t => t.GetOwner().Name.ToLower() == tokens[0].ToLower()).Where(t => !t.GetOwner().CanUseCommand("chraft.kick.exempt")))
                {
                    t.Kick(tokens.Length > 1 ? tokens[1] : "Kicked");
                    server.GetLogger().Log(LogLevel.Info, "Kicked " + t.GetOwner().Name);
                }
            }
        }

 public void Run(int port) {
   using (var mefContainer = SetupMefContainer()) {
     var server = mefContainer.GetExportedValue<IServer>();
     Instance = server; // For debugging only.
     server.Run(port);
   }
 }

		private Model GetModel(IServer server)
		{
			RequiresNotNull(server);
			var r = server.PollCurrentStatus();
			var model = new Model(r);
			return model;
		}

		/// <summary>
		/// Starts the specified server.
		/// </summary>
		/// <param name="server">The server.</param>
		public void Start(IServer server)
		{
			RequiresNotNull(server);
			var instructions = new BuildInstructions(Guid.Empty, string.Empty, string.Empty);
			try
			{
				instructions = GetBuildInstructions(server);
				BuildProject(server, instructions);
				ExecuteNUnitTestRunner(server, instructions);
			}
			catch (FileNotFoundException e)
			{
				log.Log(LogSeverity.Error,  $"The file was not found: {e.FileName}");
				var status = new ClientInformation(Environment.MachineName, instructions.Session, BuildStatus.Failed,
					new TestResult[0]);
				server.UpdateClientStatus(status);
			}
			catch (Win32Exception e)
			{
				log.Log(LogSeverity.Error, $"Error launching the build process: {e.Message}");
				var status = new ClientInformation(Environment.MachineName, instructions.Session, BuildStatus.Failed,
					new TestResult[0]);
				server.UpdateClientStatus(status);
			}
			catch (ApplicationException e)
			{
				log.Log(LogSeverity.Error, $"Error building the project: {e.Message}");
				var status = new ClientInformation(Environment.MachineName, instructions.Session, BuildStatus.Failed,
					new TestResult[0]);
				server.UpdateClientStatus(status);
			}
		}

 public SelectDatabaseViewModel(IServer server, IEventAggregator events)
     : base(events)
 {
     DisplayName = "Home";
     Server = server;
     ShowCreateDatabaseForm = Visibility.Collapsed;
 }

		public LinqEditorViewModel(IServer server)
		{
			DisplayName = "Query";
			this.server = server;

			Query = "from doc in docs " + Environment.NewLine + "select doc";
		}

        public void OnClose(IServer server)
        {
            NumOnCloseEvents++;

            if (OnCloseAction != null)
                OnCloseAction();
        }

 public EditCollectionTemplateViewModel(IServer server, IEventAggregator events,
                                        IDocumentTemplateProvider templateProvider)
 {
     this.server = server;
     this.events = events;
     this.templateProvider = templateProvider;
 }

		/// <summary>
		///     Generates a complete new ring into the provided <paramref name="ring" /> dataset. This should produce a complete 24 hour active ring which has no
		///     other logic then playing the right things at the right time, independet of the past.
		/// </summary>
		/// <param name="server">The source database</param>
		/// <param name="computerName">The name of the computer this ring is generated for.</param>
		/// <param name="ring">The target ring where all the generated data should be inserted at.</param>
		/// <remarks>
		///     Things which need to be done:
		///     <para>Set <see cref="RingMetaData.SenderId" /> to the targeting sender id.</para>
		///     <para>Generate <see cref="PageGroup" />s inside the database.</para>
		///     <para>
		///         Generate <see cref="Page" />s with the associated content (<see cref="Text" />, <see cref="Image" /> <see cref="Video" />,
		///         <see cref="DoubleTransition" />).
		///     </para>
		///     <para>
		///         Generate <see cref="PageSchedule" />s. <see cref="PageSchedule" />s in sequence which belongs to the same <see cref="PageGroup" /> needs to
		///         have the same <see cref="PageSchedule.PageGroupScheduleId" />.
		///     </para>
		/// </remarks>

		public void Generate(IServer server, string computerName, RingMetaData ring)
			{
			//if (DateTime.Now - server.Load<DateTime>("LastRefresh") > TimeSpan.FromDays(1))
			//	server.Save(StorageEnum.MultiMedia, null);

			//server.Save(StorageEnum.MultiMedia, null); //TODO Clears the current multimedia db


			MultiMedia db = GetMultiMedia(server);
			MMSender sender = GetMMSenderFromSenderOrComputerName(db, computerName);
			ring.Occasion = sender.NameId;
			ring.SenderId = sender.Id;
			sender.DataSet.SetHasBeenLoaded();
			DistributionRoot DistributionRootInstance = new DistributionRoot(db,ring.TargetDate);
			DistributionRootInstance.PreloadAllForAllTodayAndTomorrowMMunitsIfNotHasBeenLoaded();
			BalancerUsage balancerUsage = new BalancerUsage(sender, ring, ring.TargetDate)
				{
				TodaysActiveMMUnitsPerMMSlot = DistributionRootInstance.TodayActiveMMUnitsPerMMSlot
				};
			balancerUsage.LoadActuallBalancers(sender);
			RingGenerator ringGenerator = new RingGenerator(sender, ring, ring.TargetDate)
				{
				DistributionRootInstance = DistributionRootInstance,
				TodaysBalancers = (balancerUsage.TodaysBalancersPerSender.ContainsKey(sender))
						? balancerUsage.TodaysBalancersPerSender[sender] : null
				};

			ringGenerator.Generate();
			}

 /// <summary>
 /// Initializes a new instance of the <see cref="Database"/> class.
 /// </summary>
 /// <param name="server">The server.</param>
 /// <param name="binding">The binding.</param>
 public Database(IServer server, IDBBinding binding)
 {
     Server = server;
     Uri relative = binding.Uri.IsAbsoluteUri ? server.Uri.MakeRelativeUri(binding.Uri) : binding.Uri;
     Uri = new Uri(server.Uri, relative);
     Binding = binding;
 }