public HardwareInventoryCycleSccm(ILoggerService logger, IWmiServices wmiService, ISccmClientServices sccmClientService, INetworkServices networkServices, IFileAndFolderServices fileAndFolderServices) 
     : base(logger, wmiService, sccmClientService, networkServices, fileAndFolderServices)
 {
     ActionName = "Hardware Inventory Cycle";
     Description = "Forces SCCM to schedule a Hardware Inventory check on the client.";
     Category = "SCCM";
 }

 public FileCopy(ILoggerService logger, INetworkServices networkServices, IFileAndFolderServices fileAndFolderServices)
     : base(logger, networkServices, fileAndFolderServices)
 {
     ActionName = "File Copy";
     Description = "Copy file to all devices in the list.";
     Category = "Other";
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="YoufferPaymentService"/> class.
 /// </summary>
 /// <param name="loggerService">The logger service.</param>
 /// <param name="paymentRepository">The payment repository.</param>
 /// <param name="payPalDetailsRepository"> The PayPalDetails repository</param>
 /// <param name="mapperFactory">The mapper factory.</param>
 public YoufferPaymentService(ILoggerService loggerService, IRepository<LeadOpportunityMapping> paymentRepository, IRepository<PayPalDetails> payPalDetailsRepository, IMapperFactory mapperFactory)
 {
     this.LoggerService = loggerService;
     this.paymentRepository = paymentRepository;
     this.mapperFactory = mapperFactory;
     this.payPalDetailsRepository = payPalDetailsRepository;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="AccountController"/> class.
        /// </summary>
        /// <param name="logger">Logger Service</param>
        /// <param name="loginService">Login Service</param>
        /// <param name="userService">User Service</param>
        /// <param name="passwordService">Password Service</param>
        public AccountController(
            ILoggerService logger, 
            ILoginService loginService, 
            IUserService userService, 
            IPasswordService passwordService)
            : base(logger)
        {
            if (loginService == null)
            {
                throw new ArgumentNullException("ILoginService, LoginController");
            }

            if (userService == null)
            {
                throw new ArgumentNullException("IUserService, LoginController");
            }

            if(passwordService == null)
            {
                throw new ArgumentNullException("IPasswordService, LoginController");
            }

            this._loginService = loginService;
            this._userService = userService;
            this._passwordService = passwordService;
        }

 public AppDeploymentScheduleSccm(ILoggerService logger, IWmiServices wmiService, ISccmClientServices sccmClientService, INetworkServices networkServices, IFileAndFolderServices fileAndFolderServices) 
     : base(logger, wmiService, sccmClientService, networkServices, fileAndFolderServices)
 {
     ActionName = "Application Deployment Evaluation Cycle";
     Description = "Forces SCCM to schedule an Application Deployment check on the client.";
     Category = "SCCM";
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="PushService" /> class.
        /// </summary>
        /// <param name="googleGcmApiKey"> The google api key</param>
        /// <param name="appleCertPwd"> The Api certificate password</param>
        /// <param name="outputPath">The output path</param>
        /// <param name="loggerService"> The logger service</param>
        /// <param name="mapperFactory">the mapper factory</param>
        /// <param name="notificationLogRepository">The notification log repository</param>
        public PushService(string googleGcmApiKey, string appleCertPwd, string outputPath, ILoggerService loggerService, IMapperFactory mapperFactory, IRepository<NotificationLog> notificationLogRepository)
        {
            this.loggerService = loggerService;
            this.mapperFactory = mapperFactory;
            this.notificationLogRepository = notificationLogRepository;

            this.pushBroker = new PushBroker();
            try
            {
                this.pushBroker.RegisterGcmService(new GcmPushChannelSettings(googleGcmApiKey));
            }
            catch (Exception ex)
            {
                this.loggerService.LogException("Register Android notification service" + ex.Message);
            }

            var appleCert = File.ReadAllBytes(outputPath);

            try
            {
                this.pushBroker.RegisterAppleService(new ApplePushChannelSettings(appleCert, appleCertPwd));
            }
            catch (Exception ex)
            {
                this.loggerService.LogException("Register iOS notification service" + ex.Message);
            }
        }

 protected ContentViewModel(AbstractWorkspace workspace, ICommandManager commandManager, ILoggerService logger)
 {
     _workspace = workspace;
     _commandManager = commandManager;
     _logger = logger;
     CloseCommand = new DelegateCommand(CloseDocument);
 }

 public ErrorController(ILoggerService LoggerService)
 {
     if (LoggerService == null) {
         throw new ArgumentNullException("LoggerService");
     }
     this.loggerService = LoggerService;
 }

 public PingTest(ILoggerService logger, INetworkServices networkServices, IFileAndFolderServices fileAndFolderServices) 
     : base(logger, networkServices, fileAndFolderServices)
 {
     ActionName = "Ping Test";
     Description = "Runs a ping test against the device list.";
     Category = "Other";
 }

 public ToDoItemListService(IUnitOfWork uoW, IToDoItemListRepository rep, IToDoItemService itemService, ILoggerService logger)
 {
     _repository = rep;
     _unitOfWork = uoW;
     _toDoItemService = itemService;
     _loggerService = logger;
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="UserController"/> class.
        /// </summary>
        /// <param name="loggerService">Logger Service</param>
        /// <param name="userService">User Service</param>
        /// <param name="tripService">Trip Service</param>
        /// <param name="postService">Post Service</param>
        public UserController(
            ILoggerService loggerService,
            IUserService userService,
            ITripService tripService,
            IPostService postService)
            : base(loggerService)
        {
            if(userService == null)
            {
                throw new ArgumentNullException("User Service, User Controller");
            }

            if (tripService == null)
            {
                throw new ArgumentNullException("Trip Service, User Controller");
            }

            if (postService == null)
            {
                throw new ArgumentNullException("Post Service, User Controller");
            }

            this.userService = userService;
            this.tripService = tripService;
            this.postService = postService;
        }

 public ProjectVersionService(IStore<Project> projectStore, IStore<ProjectVersion> projectVersionStore, IMappingEngine mapper, ILoggerService log)
 {
     ProjectStore = projectStore;
     ProjectVersionStore = projectVersionStore;
     Mapper = mapper;
     Log = log;
 }

 public TopicsService(ITopicsDataAccess da, IMessagesDataAccess messagesDa, ISearchService searchIndex, ILoggerService loggerService)
 {
     _dataAccess = da;
     _messagesDataAccess = messagesDa;
     _searchIndex = searchIndex;
     _loggerService = loggerService;
 }

        public static Parser<DoNotAwaitAction> GetParser(
            int indentLevel,
            IAudioService audioService,
            IDelayService delayService,
            ILoggerService loggerService,
            ISpeechService speechService)
        {
            if (indentLevel < 0)
            {
                throw new ArgumentException("indentLevel must be greater than or equal to 0.", "indentLevel");
            }

            audioService.AssertNotNull(nameof(audioService));
            delayService.AssertNotNull(nameof(delayService));
            loggerService.AssertNotNull(nameof(loggerService));
            speechService.AssertNotNull(nameof(speechService));

            return
                from _ in Parse.IgnoreCase("don't")
                from __ in HorizontalWhitespaceParser.Parser.AtLeastOnce()
                from ___ in Parse.IgnoreCase("wait:")
                from ____ in VerticalSeparationParser.Parser.AtLeastOnce()
                from actions in ActionListParser.GetParser(indentLevel + 1, audioService, delayService, loggerService, speechService)
                let child = new SequenceAction(actions)
                select new DoNotAwaitAction(
                    loggerService,
                    child);
        }

 protected SccmScheduleActionBase(ILoggerService logger, IWmiServices wmiService,
     ISccmClientServices sccmClientService, INetworkServices networkServices, IFileAndFolderServices fileAndFolderServices)
     : base(logger, networkServices, fileAndFolderServices)
 {
     WmiService = wmiService;
     SccmClientService = sccmClientService;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="YoufferContactService" /> class.
 /// </summary>
 /// <param name="loggerService"> The logger service. </param>
 /// <param name="contactLeadRepository"> The Contact Lead Repository. </param> 
 /// <param name="mapperFactory"> The mapper factory. </param> 
 /// <param name="appUser"> The ApplicationUser repository. </param>
 public YoufferContactService(ILoggerService loggerService, IRepository<ContactLeadMapping> contactLeadRepository, IMapperFactory mapperFactory, IRepository<ApplicationUser> appUser)
 {
     this.LoggerService = loggerService;
     this.contactLeadRepository = contactLeadRepository;
     this.mapperFactory = mapperFactory;
     this.appUser = appUser;
 }

 public WebTestCurrentResultViewModel(AbstractWorkspace workspace, ICommandManager commandManager, ILoggerService logger, IMenuService menuService, WebTestResultView view)
     : base(workspace, commandManager, logger, menuService)
 {
     _tooltip = "Web Test Results";
     _title = "Web Test Results";
     this.View = view;
 }

        public Exercise(ILoggerService loggerService, ISpeechService speechService, string name, int setCount, int repetitionCount, IEnumerable<MatcherWithAction> matchersWithActions)
        {
            loggerService.AssertNotNull(nameof(loggerService));
            speechService.AssertNotNull(nameof(speechService));
            name.AssertNotNull(nameof(name));
            matchersWithActions.AssertNotNull(nameof(matchersWithActions));

            if (setCount < 0)
            {
                throw new ArgumentException("setCount cannot be less than zero.", "setCount");
            }

            if (repetitionCount < 0)
            {
                throw new ArgumentException("repetitionCount cannot be less than zero.", "repetitionCount");
            }

            this.logger = loggerService.GetLogger(this.GetType());
            this.speechService = speechService;
            this.name = name;
            this.setCount = setCount;
            this.repetitionCount = repetitionCount;
            this.matchersWithActions = matchersWithActions.ToImmutableList();

            using (var dummyExecutionContext = new ExecutionContext())
            {
                this.duration = this
                    .GetEventsWithActions(dummyExecutionContext)
                    .SelectMany(x => x.Actions)
                    .Select(x => x.Duration)
                    .DefaultIfEmpty()
                    .Aggregate((running, next) => running + next);
            }
        }

 public UserController(IUserService userService, ICommunicationService communicationService, ILoggerService loggerService)
 {
     this.userService = userService;
     this.communicationService = communicationService;
     this.loggerService = loggerService;
     _repo = new AuthRepository();
 }

 public UserPolicyRetrievalCycleSccm(ILoggerService logger, IWmiServices wmiService, ISccmClientServices sccmClientService, INetworkServices networkServices, IFileAndFolderServices fileAndFolderServices) 
     : base(logger, wmiService, sccmClientService, networkServices, fileAndFolderServices)
 {
     ActionName = "User Policy Retrieval Cycle";
     Description = "Forces SCCM to schedule a User Policy Retrieval check on the client.";
     Category = "SCCM";
 }