public EditorController(IRepository<Editor> editorRepository, IAccessService accessService, IEmailService emailService, IMembershipService membershipService)
 {
     _editorRepository = editorRepository;
     _accessService = accessService;
     _emailService = emailService;
     _membershipService = membershipService;
 }

 public MediaVerifyController(
       IMemberService MemberService
     , IEmailService EmailService
     , IMember_ActionService Member_ActionService
     , IOutDoorService OutDoorService
     , IIndustryCateService IndustryCateService,
     ICrowdCateService CrowdCateService,
     IOwnerCateService OwnerCateService,
     IAreaCateService AreaCateService,
     IPurposeCateService PurposeCateService,
     IFormatCateService FormatCateService,
     IPeriodCateService PeriodCateService,
     ICityCateService CityCateService,
     IMediaCateService MediaCateService,
     ICompanyService CompanyService)
 {
     this.MemberService = MemberService;
     this.EmailService = EmailService;
     this.Member_ActionService = Member_ActionService;
     this.OutDoorService = OutDoorService;
     this.IndustryCateService = IndustryCateService;
     this.CrowdCateService = CrowdCateService;
     this.OwnerCateService = OwnerCateService;
     this.AreaCateService = AreaCateService;
     this.PurposeCateService = PurposeCateService;
     this.FormatCateService = FormatCateService;
     this.PeriodCateService = PeriodCateService;
     this.CityCateService = CityCateService;
     this.MediaCateService = MediaCateService;
     this.CompanyService = CompanyService;
 }

        public InboxViewModel(IEmailService emailService, IRegionManager regionManager)
        {
            this.synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();

            this.composeMessageCommand = new DelegateCommand<object>(this.ComposeMessage);
            this.replyMessageCommand = new DelegateCommand<object>(this.ReplyMessage, this.CanReplyMessage);
            this.openMessageCommand = new DelegateCommand<EmailDocument>(this.OpenMessage);

            this.messagesCollection = new ObservableCollection<EmailDocument>();
            this.Messages = new PagedCollectionView(this.messagesCollection);
            this.Messages.CurrentChanged += (s, e) =>
                this.replyMessageCommand.RaiseCanExecuteChanged();

            this.emailService = emailService;
            this.regionManager = regionManager;

            this.emailService.BeginGetEmailDocuments(
                r =>
                {
                    var messages = this.emailService.EndGetEmailDocuments(r);

                    this.synchronizationContext.Post(
                        s =>
                        {
                            foreach (var message in messages)
                            {
                                this.messagesCollection.Add(message);
                            }
                        },
                        null);
                },
                null);
        }

 public LoanController(IEmailService mailService, IGenericRepository<Component> componentRepo, IGenericRepository<LoanInformation> loanInformationRepo, IGenericRepository<Loaner> loanerRepo)
 {
     _componentRepo = componentRepo;
     _loanInformationRepo = loanInformationRepo;
     _loanerRepo = loanerRepo;
     _mailService = mailService;
 }

 //  private readonly IEventManagerService _eventManagerService;
 public EmailService(IEmailService emailService, IMessageBusService messageBusService, IAuditService auditService/*, IEventManagerService eventManagerService*/)
 {
     _emailService = emailService;
     _messageBusService = messageBusService;
     _auditService = auditService;
      //   _eventManagerService = eventManagerService;
 }

 public PasswordService(IPersonRepository personRepository, IChurchRepository churchRepository, IUsernamePasswordRepository usernamePasswordRepository, IEmailService emailService)
 {
     _personRepository = personRepository;
     _churchRepository = churchRepository;
     _usernamePasswordRepository = usernamePasswordRepository;
     _emailService = emailService;
 }

 public UserService(IRepository<User> repository, IRepository<Role> roleRepository, IEmailService emailService, ICryptographyService cryptographyService)
 {
     _repository = repository;
     _roleRepository = roleRepository;
     _emailService = emailService;
     _cryptographyService = cryptographyService;
 }

 public AccountController(IUserService userService, ICryptographyService cryptographyService, IEmailService emailService, IImageService imageService)
 {
     _userService = userService;
     _cryptographyService = cryptographyService;
     _emailService = emailService;
     _imageService = imageService;
 }

 public UserManager(IEmailService emailService, IAuthenticationService authenticationService, IPasswordHelper passwordHelper,ISession session)
 {
     this.emailService = emailService;
     this.authenticationService = authenticationService;
     this.passwordHelper = passwordHelper;
     this.session = session;
 }

        public InboxViewModel(IEmailService emailService, IRegionManager regionManager)
        {
            synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();

            _composeMessageCommand = new DelegateCommand<object>(ComposeMessage);
            _replyMessageCommand = new DelegateCommand<object>(ReplyMessage, CanReplyMessage);
            _openMessageCommand = new DelegateCommand<EmailDocument>(OpenMessage);

            messagesCollection = new ObservableCollection<EmailDocument>();
            Messages = new CollectionView(this.messagesCollection);
            Messages.CurrentChanged += (s, e) =>
                _replyMessageCommand.RaiseCanExecuteChanged();

            _emailService = emailService;
            _regionManager = regionManager;

            if (_emailService != null)
            {
                _emailService.BeginGetEmailDocuments(
                    r =>
                        {
                            var messages = _emailService.EndGetEmailDocuments(r);
                            synchronizationContext.Post(
                                s =>
                                    {
                                        foreach (var message in messages)
                                        {
                                            messagesCollection.Add(message);
                                        }
                                    }, null);
                        }, null);
            }
        }

        public void BeforeEach()
        {
            _productRepo = Substitute.For<IProductRepository>();
            _orderFulfillmentService = Substitute.For<IOrderFulfillmentService>();
            _customerRepository = Substitute.For<ICustomerRepository>();
            _taxRateService = Substitute.For<ITaxRateService>();
            _emailService = Substitute.For<IEmailService>();

            _subject = new OrderService(_orderFulfillmentService,
                _customerRepository,
                _taxRateService,
                _emailService);

            _bestCustomer = new Customer
            {
                CustomerId = 42,
                PostalCode = "12345",
                Country = "Merica"
            };

            _listOfTaxEntries = new List<TaxEntry>
            {
                new TaxEntry {Description = "High Tax", Rate = (decimal) 0.60},
                new TaxEntry {Description = "Low Tax", Rate = (decimal) 0.10}
            };

            _orderConfirmation = new OrderConfirmation
            {
                OrderId = 1234,
                OrderNumber = "hello"
            };
            _customerRepository.Get(_bestCustomer.CustomerId.Value).Returns(_bestCustomer);
            _taxRateService.GetTaxEntries(_bestCustomer.PostalCode, _bestCustomer.Country).Returns(_listOfTaxEntries);
        }

        public UserService(UserManager<IUserDto, int> userManager,
            IUserDtoMapper userDtoMapper,
            IEmailService emailService,
            EntityValidator entityValidator,
            IUserRepository userRepository,
            Func<object, ValidationContext> validationContextFactory = null)
        {
            if (userManager == null)
            {
                throw new ArgumentNullException("userManager");
            }

            if (userDtoMapper == null)
            {
                throw new ArgumentNullException("userDtoMapper");
            }

            if (emailService == null)
            {
                throw new ArgumentNullException("emailService");
            }

            _userRepository = userRepository;
            _userDtoMapper = userDtoMapper;
            _emailService = emailService;
            _entityValidator = entityValidator;
            _validationContextFactory = validationContextFactory ?? (o => new ValidationContext(o, null, null));
            _userManager = userManager;
            _userManager.UserValidator = new UserValidator<IUserDto, int>(_userManager){AllowOnlyAlphanumericUserNames = false};
        }

 public AdminController(IEmailService emailService, IEmployeeService employeeservice, IProjectService projectService, ISkillSetService skillsetservice)
 {
     _projectService = projectService;
     _employeeService = employeeservice;
     _emailService = emailService;
     _skillsetservice = skillsetservice;
 }

 /// AccountHelper
 public AccountHelper(IGenericUnitofWork uow, IMembershipService membershipService, IUserHelper userHelper, IEmailService emailService)
 {
     UnitofWork = uow;
     MembershipService = membershipService;
     UserHelper = userHelper;
     EmailService = emailService;
 }

 public PaymentService(IUserService userService, IEmailService emailService)
 {
     _emailService = emailService;
     _userService = userService;
     _owin = HttpContext.Current.GetOwinContext();
     _dbContext = _owin.Get<ApplicationDbContext>();
 }

 public PetitionController(IEmailService emailService, ICeremonyService ceremonyService, IPetitionService petitionService, IErrorService errorService)
 {
     _emailService = emailService;
     _ceremonyService = ceremonyService;
     _petitionService = petitionService;
     _errorService = errorService;
 }

		public TimetableServiceWithEmail(ITimetableService innerTimetableService, IEmailService emailService)
		{
			if (innerTimetableService == null) throw new ArgumentNullException("Inner timetable service");
			if (emailService == null) throw new ArgumentNullException("Email service");
			_innerTimetableService = innerTimetableService;
			_emailService = emailService;
		}

        public AttendingUserDetailsViewModel(ICTimeService cTimeService, IApplicationStateService applicationStateService, IContactsService contactsService, IDialogService dialogService, IPhoneService phoneService, IEmailService emailService)
        {
            Guard.NotNull(cTimeService, nameof(cTimeService));
            Guard.NotNull(applicationStateService, nameof(applicationStateService));
            Guard.NotNull(contactsService, nameof(contactsService));
            Guard.NotNull(dialogService, nameof(dialogService));
            Guard.NotNull(phoneService, nameof(phoneService));
            Guard.NotNull(emailService, nameof(emailService));

            this._cTimeService = cTimeService;
            this._applicationStateService = applicationStateService;
            this._contactsService = contactsService;
            this._dialogService = dialogService;
            this._phoneService = phoneService;
            this._emailService = emailService;

            this.LoadAttendingUser = UwCoreCommand.Create(this.LoadAttendingUserImpl)
                .HandleExceptions()
                .ShowLoadingOverlay(CTime2Resources.Get("Loading.Employee"));
            this.LoadAttendingUser.ToProperty(this, f => f.AttendingUser, out this._attendingUserHelper);
            
            var canCall = Observable
                .Return(this._phoneService.CanCall)
                .CombineLatest(this.WhenAnyValue(f => f.AttendingUser), (serviceCanCall, user) => 
                    serviceCanCall && string.IsNullOrWhiteSpace(user?.PhoneNumber) == false);
            this.Call = UwCoreCommand.Create(canCall, this.CallImpl)
                .HandleExceptions();

            var canSendMail = this.WhenAnyValue(f => f.AttendingUser, selector: user => string.IsNullOrWhiteSpace(user?.EmailAddress) == false);
            this.SendMail = UwCoreCommand.Create(canSendMail, this.SendMailImpl)
                .HandleExceptions();

            this.AddAsContact = UwCoreCommand.Create(this.AddAsContactImpl)
                .HandleExceptions();
        }

 public OrderService(IOrderRepository orderRepository, ICustomerFactory customerFactory, IEmailService emailService, IOrderSettings orderSettings)
 {
     _orderRepository = orderRepository;
     _customerFactory = customerFactory;
     _emailService = emailService;
     _orderSettings = orderSettings;
 }

 public PersonService(
     IPersonRepository personRepository, 
     IPersonGroupRepository personGroupRepository, 
     IPermissionRepository permissionRepository, 
     IPersonRoleRepository personRoleRepository, 
     IPersonOptionalFieldRepository personOptionalFieldRepository, 
     IRelationshipRepository relationshipRepository,
     IChurchMatcherRepository churchMatcherRepository,
     IGroupRepository groupRepository,
     IFamilyRepository familyRepository,
     IEmailService emailService,
     IAddressRepository addressRepository,
     IPhotoRepository photoRepository)
 {
     _personRepository = personRepository;
     _personGroupRepository = personGroupRepository;
     _permissionRepository = permissionRepository;
     _personRoleRepository = personRoleRepository;
     _personOptionalFieldRepository = personOptionalFieldRepository;
     _relationshipRepository = relationshipRepository;
     _churchMatcherRepository = churchMatcherRepository;
     _groupRepository = groupRepository;
     _familyRepository = familyRepository;
     _emailService = emailService;
     _addressRepository = addressRepository;
     _photoRepository = photoRepository;
 }