public FilesController(IFileSystemService fileSystemService, IUnitOfWorkFactory unitOfWorkFactory, ILogService logService, ICacheWrapper cacheWrapper)
 {
     _fileSystemService = fileSystemService;
     _unitOfWorkFactory = unitOfWorkFactory;
     _logService = logService;
     _cacheWrapper = cacheWrapper;
 }

		public OAuthClientHandlerService ()
			:base()
		{
			appContext = Application.Context;
			tcs = new TaskCompletionSource<OAuthResult> ();
			logger = ServiceFinder.Resolve<ILogService> ();
		}

        public BasicReportModule(IRegionManager regionManager, BasicReportView basicReportView,
            IWorkPeriodService workPeriodService, IPrinterService printerService, ICacheService cacheService,
            IInventoryService inventoryService, IUserService userService, IAutomationService automationService,
            IApplicationState applicationState, ILogService logService, ISettingService settingService)
            : base(regionManager, AppScreens.ReportView)
        {
            ReportContext.PrinterService = printerService;
            ReportContext.WorkPeriodService = workPeriodService;
            ReportContext.InventoryService = inventoryService;
            ReportContext.UserService = userService;
            ReportContext.ApplicationState = applicationState;
            ReportContext.CacheService = cacheService;
            ReportContext.LogService = logService;
            ReportContext.SettingService = settingService;

            _userService = userService;

            _regionManager = regionManager;
            _basicReportView = basicReportView;
            SetNavigationCommand(Resources.Reports, Resources.Common, "Images/Ppt.png", 60);

            PermissionRegistry.RegisterPermission(PermissionNames.OpenReports, PermissionCategories.Navigation, Resources.CanDisplayReports);
            PermissionRegistry.RegisterPermission(PermissionNames.ChangeReportDate, PermissionCategories.Report, Resources.CanChangeReportFilter);

            //todo refactor
            automationService.RegisterParameterSource("ReportName", () => ReportContext.Reports.Select(x => x.Header));

        }

 private LogController CreateLogController(ILogService logService)
 {
     var userService = new Mock<IUserService>();
     var mapper = new Mock<IMapperService>();
     var controller = new LogController(userService.Object, logService, mapper.Object);
     return controller;
 }

 public WorkPeriodService(IWorkPeriodDao workPeriodDao, IApplicationState applicationState, IApplicationStateSetter applicationStateSetter, ILogService logService)
 {
     _workPeriodDao = workPeriodDao;
     _applicationState = applicationState;
     _applicationStateSetter = applicationStateSetter;
     _logService = logService;
 }

 public NavigatorService(IEventAggregator eventAggregator, IUrlParameterToObjectsPlateHeater urlParameterToObjectsPlateHeater, ILogService logService, INotificationService notificationService)
 {
     _eventAggregator = eventAggregator;
     this._notificationService = notificationService;
     this._logService = logService;
     _urlParameterToObjectsPlateHeater = urlParameterToObjectsPlateHeater;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="ImportService"/> class.
 /// </summary>
 /// <param name="settingsService">
 /// Провайдер настроек
 /// </param>
 /// <param name="fileSystemService">
 /// Сервис файловой системы
 /// </param>
 /// <param name="logService">
 /// Сервис логирования
 /// </param>
 /// <param name="dateTimeService">
 /// Сервис даты/времени
 /// </param>
 public ImportService(IAlbumeSettingsService settingsService, IFileSystemService fileSystemService, ILogService logService, IDateTimeService dateTimeService)
 {
     this.settingsService = settingsService;
     this.fileSystemService = fileSystemService;
     this.logService = logService;
     this.dateTimeService = dateTimeService;
 }

 public SiteCollectionController(ISiteTemplateService siteTemplateService,
     ICreateRequestService createRequestService, ILogService logService)
 {
     _siteTemplateService = siteTemplateService;
     _createRequestService = createRequestService;
     _logService = logService;
 }

 public ProgramSettingsManager(ISystemEnvironment systemEnvironment, ILogService logService,
     IStorageService storageService)
 {
     _systemEnvironment = systemEnvironment;
     _storageService = storageService;
     _logService = logService;
 }

 public WizardPlugin(ILogService logger)
   : base(logger)
 {
   //we must have the highest merit to force display above all else
   DefaultMerit = (int)MeritLevel.Max;
   DefaultAssetGroup = WizardAssetGroup;
 }

        /// <summary>
        /// Constructor for the Application object.
        /// </summary>
        public App()
        {
            // Global handler for uncaught exceptions.
            UnhandledException += Application_UnhandledException;

            // Show graphics profiling information while debugging.
            if (System.Diagnostics.Debugger.IsAttached)
            {
                // Display the current frame rate counters.
                Application.Current.Host.Settings.EnableFrameRateCounter = true;

                // Show the areas of the app that are being redrawn in each frame.
                //Application.Current.Host.Settings.EnableRedrawRegions = true;

                // Enable non-production analysis visualization mode,
                // which shows areas of a page that are being GPU accelerated with a colored overlay.
                //Application.Current.Host.Settings.EnableCacheVisualization = true;
            }

            // Standard Silverlight initialization
            InitializeComponent();

            // App specific settings initialization
            InitializeSettings();

            // Phone-specific initialization
            InitializePhoneApplication();

            this._logService = IoC.Container.Get<ILogService>();
        }

        public static void Initialize(ILogService logger)
        {
            if (logger == null)
                throw new ArgumentNullException();

            _logger = logger;
        }

        public AudioRenderingService(IAudioStationSession audioStationSession)
        {
            // todo : inject ?
            _logService = IoC.Container.Get<ILogService>();

            _logService.Trace("AudioRenderingService .ctor");
            if (audioStationSession == null)
            {
                throw new ArgumentNullException("audioStationSession");
            }
            _audioStationSession = audioStationSession;

            //_mediaElement = (MediaElement)Application.Current.Resources["MediaElement"];

            BufferPlayableHeuristicPredicate = (track, bytesLoaded) =>  bytesLoaded >= track.Bitrate||  bytesLoaded == track.Size;

            //_mediaElement.MediaFailed += MediaFailed;

            // TODO : Add error handling

            // TODO : Add position handling BackgroundAudioPlayer.Instance.Position
            // _mediaElement.SetBinding(MediaElement.PositionProperty, new Binding { Source = this, Mode = BindingMode.TwoWay, Path = new PropertyPath(PositionPropertyName)  });

            // todo : handle state changes
            // _mediaElement.CurrentStateChanged += OnCurrentStateChanged;

            //_mediaElement.MediaOpened += MediaOpened;

            // todo : handle end of track
            //_mediaElement.MediaEnded += PlayingMediaEnded;
        }

        /// <summary>
        /// Appends the specified log service to a root log service (the current instance).
        /// </summary>
        /// <param name="logService">The log service.</param>
        /// <param name="additionalData">The optional additional data.</param>
        /// <returns>
        /// An implementation of <see cref="ILogLevelThresholdSelector"/> allowing to set a maximum log level to trace.
        /// </returns>
        public ILogLevelThresholdSelector AppendLogService(ILogService logService, IDictionary<string, object> additionalData = null)
        {
            if (logService == null) throw new ArgumentNullException("logService");

            if (RootLog4NetService == null) return null;
            return RootLog4NetService.AppendLogService(logService, additionalData);
        }

        public InventoryModule(IRegionManager regionManager, ICacheService cacheService, IUserService userService, IInventoryService inventoryService,
            WarehouseInventoryView resourceInventoryView, WarehouseInventoryViewModel resourceInventoryViewModel, ILogService logService)
            : base(regionManager, AppScreens.InventoryView)
        {
            _regionManager = regionManager;
            _cacheService = cacheService;
            _userService = userService;
            _inventoryService = inventoryService;
            _warehouseInventoryView = resourceInventoryView;
            _warehouseInventoryViewModel = resourceInventoryViewModel;
            _logService = logService;

            AddDashboardCommand<EntityCollectionViewModelBase<WarehouseTypeViewModel, WarehouseType>>(Resources.WarehouseType.ToPlural(), Resources.Inventory, 35);
            AddDashboardCommand<EntityCollectionViewModelBase<WarehouseViewModel, Warehouse>>(Resources.Warehouse.ToPlural(), Resources.Inventory, 35);
            AddDashboardCommand<EntityCollectionViewModelBase<TransactionTypeViewModel, InventoryTransactionType>>(Resources.TransactionType.ToPlural(), Resources.Inventory, 35);
            AddDashboardCommand<EntityCollectionViewModelBase<TransactionDocumentTypeViewModel, InventoryTransactionDocumentType>>(Resources.DocumentType.ToPlural(), Resources.Inventory, 35);
            AddDashboardCommand<TransactionDocumentListViewModel>(Resources.Transaction.ToPlural(), Resources.Inventory, 35);

            AddDashboardCommand<EntityCollectionViewModelBase<InventoryItemViewModel, InventoryItem>>(Resources.InventoryItems, Resources.Inventory, 35);
            AddDashboardCommand<RecipeListViewModel>(Resources.Recipes, Resources.Inventory, 35);
            AddDashboardCommand<PeriodicConsumptionListViewModel>(Resources.EndOfDayRecords, Resources.Inventory, 36);

            SetNavigationCommand(Resources.Warehouses, Resources.Common, "Images/box.png", 40);

            EventServiceFactory.EventService.GetEvent<GenericEvent<Entity>>().Subscribe(OnResourceEvent);
            EventServiceFactory.EventService.GetEvent<GenericEvent<Warehouse>>().Subscribe(OnWarehouseEvent);

            PermissionRegistry.RegisterPermission(PermissionNames.OpenInventory, PermissionCategories.Navigation, string.Format(Resources.CanNavigate_f, Resources.Inventory));
        }

 public LogController(IUserService userService,
     ILogService logService,
     IMapperService mapper)
     : base(userService, logService)
 {
     _mapper = mapper;
 }

        /// <summary>
        /// Public constructor to initialize product service instance
        /// </summary>

        public DataController(
            ILogUnitOfWorkAsync unitOfWorkAsync,
            ILogService LogService)
       {
            _unitOfWorkAsync = unitOfWorkAsync;
            _LogService = LogService;
        }

 public AssetService(IAppServiceRepository svcRepo, IThemeService themeSvc, ILogService logSvc)
 {
   AppServiceRepository = svcRepo;
   ThemeService = themeSvc;
   LogService = logSvc;
   Assets = new Collection<Asset>();
 }

        public NoteController(INoteService noteService, IUserService userService
 , ILogService logService
            )
            : base(userService, logService)
        {
            this.serviceNote = noteService;
        }

 public FollowController(IFollowService followService, IUserService userService
     , ILogService logService
     )
     : base(userService, logService)
 {
     this.serviceFollow = followService;
 }