public WebSocketInterface(int port, ITranslation translations)
        {
            _server = new WebSocketServer();
            var setupComplete = _server.Setup(new ServerConfig
            {
                Name = "NecroWebSocket",
                Ip = "Any",
                Port = port,
                Mode = SocketMode.Tcp,
                Security = "tls",
                Certificate = new CertificateConfig
                {
                    FilePath = @"cert.pfx",
                    Password = "necro"
                }
            });

            if (setupComplete == false)
            {
                Logger.Write(translations.GetTranslation(TranslationString.WebSocketFailStart, port), LogLevel.Error);
                return;
            }

            _server.NewMessageReceived += HandleMessage;
            _server.NewSessionConnected += HandleSession;

            _server.Start();
        }

 public HomeController(IHomeZoneService homeZoneService, IMenuService menuService, ITranslation translation)
 {
     //_userManager = userManager;
     _homeZoneService = homeZoneService;
     _menuService = menuService;
     _translation = translation;
 }

		public ArticleDetailPage(ITranslation translation, IArticleDetailPageViewModel viewModel)
		{
			_translation = translation;
			_viewModel = viewModel;
			BindingContext = _viewModel;
			CreateUI();
		}

 public MenuService(IMenuHolder holder,
     IAccountPermissionsManager userPermissionsManager, ITranslation translation)
 {
     _holder = holder;
     _userPermissionsManager = userPermissionsManager;
     _translation = translation;
 }

        public static void AddTranslationItemsFromFields(string category, object obj, ITranslation translation)
        {
            if (obj == null)
                return;

            AddTranslationItemsFromList(category, translation, GetObjProperties(obj, "$this"));
        }

		private void EnsureTranslationIsNotADuplicate(ITranslation translationToAdd)
		{
			if (_translations.ContainsKey(translationToAdd.IsoCode))
			{
				throw new Exception(String.Format("{0} has already been added as a translation", translationToAdd.IsoCode));
			}
		}

		public void AddTranslation(ITranslation translation)
		{
			EnsureOnlyOneDefaultLanguage(translation);
			EnsureTranslationIsNotADuplicate(translation);

			_translations.Add(translation.IsoCode, translation);
		}

 public TEditor(ListBox lb, ISong song, GUI owner, ITranslation trans)
 {
     //
     // Erforderlich für die Windows Form-Designerunterstützung
     //
     InitializeComponent();
     this.AcceptButton = this.button1;
     this.song = song;
     this.trans = trans;
     this.lb = lb;
     this.owner = owner;
     this.textBox2.Text = this.song.Number.ToString();
     this.textBox2.Enabled = false;
     tEditor = this;
     TEditorOpen = true;
     if (this.trans != null)
     {
         this.textBox1.Text = this.trans.Title;
         this.richTextBox1.Text = this.trans.Text;
         this.checkBox1.Checked = this.trans.Unformatted;
         this.panel1.Enabled = !this.trans.Unformatted;
     }
     else
     {
         this.textBox1.Text = "";
         this.richTextBox1.Text = "";
     }
 }

		private void EnsureOnlyOneDefaultLanguage(ITranslation translationToAdd)
		{
			if ((translationToAdd.IsDefault) 
				&& (_translations.Any(t => t.Value.IsDefault)))
			{
				throw new Exception("Only one default langauge is allowed.");
			}
		}

 public IList<ITranslation> GetSimilarTranslations(
     ITranslation sourceTranslation, 
     IList<ITranslation> targetTranslations)
 {
     return targetTranslations
         .Where(translation => translation.Source.Id == sourceTranslation.Source.Id ||
             translation.Target.Id == sourceTranslation.Target.Id)
         .ToList();
 }

		public LoginPage(ILoginPageViewModel viewModel, ITranslation translation, IViewLocator viewLocator)
		{
			_viewModel = viewModel;
			_viewModel.NavigateToMainPageCommand = new Command(async () => await NavigateToMainPage());
			BindingContext = _viewModel;

			_translation = translation;
			_viewLocator = viewLocator;
		}

 /// <summary>
 /// Creates a new map message.
 /// </summary>
 /// <param name="text">The message.</param>
 /// <param name="boundary">The boundary object.</param>
 /// <param name="translation">The map translation.</param>
 public MapInfoAnnotation(string text, IAnchor boundary, ITranslation translation)
     : base(text, null, translation)
 {
     // Validate the parameters.
     if (null == boundary) throw new ArgumentNullException("boundary");
     if (null == translation) throw new ArgumentNullException("translation");
     // Set the annotation defaults.
     this.BackgroundColor = Color.White;
     this.Visible = false;
     // Set the boundary anchor.
     this.boundary = boundary;
 }

 public static void AddTranslationItemsFromList(string category, ITranslation translation, IEnumerable<Tuple<string, object>> items)
 {
     Action<string, object, PropertyInfo> action = delegate(string item, object itemObj, PropertyInfo propertyInfo)
     {
         var value = (string)propertyInfo.GetValue(itemObj, null);
         if (AllowTranslateProperty(value))
         {
             translation.AddTranslationItem(category, item, propertyInfo.Name, value);
         }
     };
     ForEachItem(items, action);
 }

		public ArticleMasterPage(ITranslation translation, 
			IArticleMasterPageViewModel viewModel,
			IArticlesHubProxy articlesHub,
			IViewLocator viewLocator)
		{
			_translation = translation;
			_viewModel = viewModel;
			_articlesHub = articlesHub;
			_viewLocator = viewLocator;
			BindingContext = _viewModel;
			CreateUI();
			this.SetDefaultPadding();
		}

 public static ITranslation GetTranslation(string translationName)
 {
     if (string.IsNullOrEmpty(translationName))
     {
         _translation = null;
     }
     else if (!translationName.Equals(_name))
     {
          _translation = TranslationSerializer.Deserialize(Path.Combine(GetTranslationDir(), translationName + ".xlf"));
     }
     _name = translationName;
     return _translation;
 }

 public RoleController(IRoleService roleService,
     IModuleManager moduleManager,
     IPermissionManager permissionManager,
     IMenuService menuService,
     IRoleBelongsSystemService belongsSystemService,
     IAuthorizer authorizer, ITranslation translation,
     IRolePermissionsService rolePermissionsService)
 {
     _roleService = roleService;
     _moduleManager = moduleManager;
     _permissionManager = permissionManager;
     _menuService = menuService;
     _belongsSystemService = belongsSystemService;
     _authorizer = authorizer;
     _translation = translation;
     _rolePermissionsService = rolePermissionsService;
 }

        public static void AddTranslationItem(string category, object obj, string propName, ITranslation translation)
        {
            if (obj == null)
                return;

            var propertyInfo = obj.GetType().GetProperty(propName,
                BindingFlags.Public | BindingFlags.Instance | BindingFlags.Static |
                BindingFlags.NonPublic | BindingFlags.SetProperty);
            if (propertyInfo == null)
            {
                return;
            }
            var value = propertyInfo.GetValue(obj, null) as string;
            if (value != null && AllowTranslateProperty(value))
            {
                translation.AddTranslationItem(category, propName, "Text", value);
            }
        }

 public AccountController(ISsoSetting ssoSetting, IAuthenticationService svcAuthentication, IAuthService svcAuth,
     IAuthorizationCodeManager authorizationCodeManager, 
     IClientVerifier clientVerifier,
     ITranslation translation,
     IAccountRegisterManager accountRegisterManager,
     IClientManager clientManager,
     IValidateCodeBuilder validateCodeBuilder,
     IAuthorizationCodeHolder authorizationCodeHolder)
 {
     _svcAuthentication = svcAuthentication;
     _svcAuth = svcAuth;
     _authorizationCodeManager = authorizationCodeManager;
     _clientVerifier = clientVerifier;
     _translation = translation;
     _accountRegisterManager = accountRegisterManager;
     _clientManager = clientManager;
     _validateCodeBuilder = validateCodeBuilder;
     _authorizationCodeHolder = authorizationCodeHolder;
     _ssoSetting = ssoSetting;
     Logger =NullLogger.Instance;
 }

        public IManyToManyRelationship SaveTranslation(
            ITranslation translation, 
            out ServiceOperationAction action)
        {
            action = ServiceOperationAction.Update;
            if (!translationValidator.Validate(translation).Status)
            {
                throw new ValidationFailedException();
            }

            using (var context = ContextFactory.Build())
            {
                var targetTranslation = GetTranslation(translation.Id) ??
                                        GetTranslation(translation.Source.Id, translation.Target.Id);

                if (targetTranslation == null)
                {
                    targetTranslation = context.Translations.CreateObject<Translation>();
                    context.Translations.AddObject(targetTranslation);
                    action = ServiceOperationAction.Create;
                }
                else
                {
                    context.Attach(targetTranslation);
                    action = ServiceOperationAction.Update;
                }

                targetTranslation.Source = context.Words.Single(item => item.Id == translation.Source.Id);
                targetTranslation.Target = context.Words.Single(item => item.Id == translation.Target.Id);

                context.SaveChanges();
                // TODO: to factory
                return new ManyToManyRelationship
                                        {
                                            Id = targetTranslation.Id,
                                            SourceId = targetTranslation.SourceId,
                                            TargetId = targetTranslation.TargetId
                                        };
            }
        }

        public static void AddTranslationItemsFromList(string category, ITranslation translation, IEnumerable<Tuple<string, object>> items)
        {
            foreach (var item in items)
            {
                var itemName = item.Item1;
                var itemObj = item.Item2;
                foreach (var property in GetItemPropertiesEnumerator(item))
                {
                    var value = property.GetValue(itemObj, null);
                    if (value == null)
                        continue;
                    var valueStr = value as string;
                    if (valueStr != null)
                    {
                        if (AllowTranslateProperty(valueStr))
                        {
                            translation.AddTranslationItem(category, itemName, property.Name, valueStr);
                        }
                        continue;
                    }

                    var listItems = value as IList;
                    if (listItems != null)
                    {
                        for (int index = 0; index < listItems.Count; index++)
                        {
                            var listItem = listItems[index] as string;
                            if (AllowTranslateProperty(listItem))
                            {
                                translation.AddTranslationItem(category, itemName, "Item" + index, listItem);
                            }
                        }
                    }
                }
            }
        }