public UserService(IUserAccountRepository userAccountRepository, ICustomerRepository customerRepository, IUserRoleRepository userRoleRepository, IRoleRepository roleRepository)
 {
     _customerRepository = customerRepository;
     _userRoleRepository = userRoleRepository;
     _roleRepository = roleRepository;
     _userAccountRepository = userAccountRepository;
 }

        public FakeSiteUserRoleRepository(ISiteUserRepository siteUserRepo, IRoleRepository roleRepo)
        {
            list.Add(new SiteUserRole(1, 1, 1));
            list.Add(new SiteUserRole(2, 2, 2));
            list.Add(new SiteUserRole(3, 2, 1));
            list.Add(new SiteUserRole(4, 3, 3));
            list.Add(new SiteUserRole(5, 3, 2));
            list.Add(new SiteUserRole(6, 3, 1));
            list.Add(new SiteUserRole(7, 4, 4));
            list.Add(new SiteUserRole(8, 4, 3));
            list.Add(new SiteUserRole(9, 4, 2));
            list.Add(new SiteUserRole(10, 4, 1));

            var users = siteUserRepo.Get();
            var maxUserId = users.Max(x=>x.Id);
            var minUserId = 5;
            var roles = roleRepo.Get();
            var maxRoleId = roles.Max(x=>x.Id);
            var minRoleId = roles.Min(x=>x.Id);
            for (int i = 11; i <= 20 ; i++)
            {
                var userId = (i % (maxUserId+1 - minUserId)) + minUserId;
                var roleId = (i % (maxRoleId+1 - minRoleId)) + minRoleId;
                if (!this.list.Any(x => x.RoleId == roleId && x.SiteUserId == userId))
                {
                    list.Add(new SiteUserRole(i, userId, roleId));
                }
            }
        }

 public UserRoleListModel(IRoleRepository roleRepository, IUserRoleRepository userRoleRepository, IUnitOfWork unitOfWork)
     : base()
 {
     _roleRepository = roleRepository;
     _userRoleRepository = userRoleRepository;
     _unitOfWork = unitOfWork;
 }

 public RoleAppService(IRoleQuery roleQuery, IRoleRepository roleRepository,
     IRoleFunctionRepository roleFunctionRepository)
 {
     _roleQuery = roleQuery;
     _roleRepository = roleRepository;
     _roleFunctionRepository = roleFunctionRepository;
 }

 public void Setup()
 {
     _domainService = Substitute.For<IUserDomainService>();
     _roleRepository = Substitute.For<IRoleRepository>();
     _userRepository = Substitute.For<IUserRepository>();
     _handler = new CreateAdminUserAccountCommandHandler(_domainService, _userRepository,_roleRepository);
 }

 public TenantProvisioningService(ITenantRepository tenantRepository, IUserRepository userRepository,
     IRoleRepository roleRepository)
 {
     this._tenantRepository = tenantRepository;
     this._userRepository = userRepository;
     this._roleRepository = roleRepository;
 }

 public AuthorizationService(IUserRepository userRepository, IGroupRepository groupRepository,
     IRoleRepository roleRepository)
 {
     this._roleRepository = roleRepository;
     this._userRepository = userRepository;
     this._groupRepository = groupRepository;
 }

 public void AddUsersToRoles()
 {
     var users = Builder<User>.CreateListOfSize(2).
         TheFirst(1).With(x => x.Login = "A").
         TheLast(1).With(x => x.Login = "B").Build();
     var roles = Builder<Role>.CreateListOfSize(2).
         TheFirst(1).With(x => x.RoleName = "User").
         TheLast(1).With( x => x.RoleName = "Admin").Build();
     _userRepository = Mockery.Stub<IUserRepository>();
     _roleRepository = Mockery.Stub<IRoleRepository>();
     using (Mockery.Record())
     {
         Expect.Call(_userRepository.GetUserByLogin("A")).Return(users[0]);
         Expect.Call(_userRepository.GetUserByLogin("B")).Return(users[1]);
         Expect.Call(_roleRepository.GetRoleByRoleName("User")).Return(roles[0]);
         Expect.Call(_roleRepository.GetRoleByRoleName("Admin")).Return(roles[1]);
     }
     using (Mockery.Playback())
     {
         _roleService = new RoleService(_roleRepository, _userRepository);
         _roleService.AddUsersToRoles(new[] {"A", "B"}, new[] {"User", "Admin"});
     }
     Assert.AreEqual(users[0].Roles.Count, 2);
     Assert.AreEqual(users[1].Roles.Count, 2);
 }

 public UserService(IUnitOfWork uow, IUserRepository repository, IRoleRepository roleRepository)
 {
     this.uow = uow;
     this.userRepository = repository;
     this.roleRepository = roleRepository;
     //Debug.WriteLine("service create!");
 }

 public RoleService(IRoleRepository roleRepository, ICategoryPermissionForRoleRepository categoryPermissionForRoleRepository, IPermissionRepository permissionRepository, IGlobalPermissionForRoleRepository globalPermissionForRoleRepository)
 {
     _roleRepository = roleRepository;
     _categoryPermissionForRoleRepository = categoryPermissionForRoleRepository;
     _permissionRepository = permissionRepository;
     _globalPermissionForRoleRepository = globalPermissionForRoleRepository;
 }

 public AdminController(ICampaignRepository campaignRepository, IRoleRepository roleRepository)
 {
     this.campaignRepository = campaignRepository;
     this.roleRepository = roleRepository;
     Mapper.CreateMap<Organization, OrganizationDetailsModel>();
     Mapper.CreateMap<OrganizationSetting, OrganizationSettingModel>();
 }

 public UserService(ModelStateDictionary modelState, 
     IUserRepository userRepository, IRoleRepository roleRepository)
 {
     _modelState = modelState;
     _users = userRepository;
     _roles = roleRepository;
 }

 public UserProjectRoleRelationLogic(IUserRepository userRepository,  IUserProjectRoleRelationRepository userProjectRoleRelationRepository, IRoleRepository roleRepository, IProjectRepository projectRepository)
 {
     _userRepository = userRepository;
     _userProjectRoleRelationRepository = userProjectRoleRelationRepository;
     _roleRepository = roleRepository;
     _projectRepository = projectRepository;
 }

 public ProfileController(IRoleRepository roleRepository, IEmployeeRepository employeeRepository, IDepartmentRepository departmentRepository, ISeatingFloorRespository seatingFloorRespository)
 {
     this.roleRepository = roleRepository;
     this.employeeRepository = employeeRepository;
     this.departmentRepository = departmentRepository;
     this.seatingFloorRespository = seatingFloorRespository;
 }

 public EveOnlineService(
     IUnitOfWork unitOfWork,
     IEveOnlineConstellationRepository eveOnlineConstellationRepository,
     IEveOnlineTypeRepository eveOnlineTypeRepository,
     IEveOnlineRegionRepository eveOnlineRegionRepository,
     IEveOnlineSolarSystemRepository eveOnlineSolarSystemRepository,
     IGenericRepository<EveOnlineSkill> eveOnlineSkillRepository,
     IGenericRepository<EveOnlineSkillGroup> eveOnlineSkillGroupRepository,
     IGenericRepository<EveOnlineSkillTree> eveOnlineSkillTreeRepository,
     IEveOnlineRequiredSkillRepository eveOnlineRequiredSkillRepository,
     IGenericRepository<EveOnlineAttribute> eveOnlineAttributeRepository,
     IGenericRepository<UserLog> userLogRepository,
     IRoleRepository roleRepository)
 {
     UnitOfWork = unitOfWork;
     _eveOnlineConstellationRepository = eveOnlineConstellationRepository;
     _eveOnlineTypeRepository = eveOnlineTypeRepository;
     _eveOnlineRegionRepository = eveOnlineRegionRepository;
     _eveOnlineSolarSystemRepository = eveOnlineSolarSystemRepository;
     _eveOnlineSkillRepository = eveOnlineSkillRepository;
     _eveOnlineSkillGroupRepository = eveOnlineSkillGroupRepository;
     _eveOnlineSkillTreeRepository = eveOnlineSkillTreeRepository;
     _eveOnlineRequiredSkillRepository = eveOnlineRequiredSkillRepository;
     _eveOnlineAttributeRepository = eveOnlineAttributeRepository;
     _userLogRepository = userLogRepository;
     _roleRepository = roleRepository;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="FunctionService"/> class.
 /// </summary>
 /// <param name="functionRepository">
 /// The function repository.
 /// </param>
 /// <param name="userRepository">
 /// The user repository.
 /// </param>
 /// <param name="functionInRoleRepository">
 /// The function in role repository.
 /// </param>
 /// <param name="userInRoleRepository">
 /// The user in role repository.
 /// </param>
 public FunctionService(IFunctionRepository functionRepository, IUserRepository userRepository, IFunctionInRoleRepository functionInRoleRepository, IUserInRoleRepository userInRoleRepository, IRoleRepository roleRepository)
 {
     this.functionRepository = functionRepository;
     this.userRepository = userRepository;
     this.functionInRoleRepository = functionInRoleRepository;
     this.userInRoleRepository = userInRoleRepository;
     this.roleRepository = roleRepository;
 }

 public AbilityAuthorizationService(IUserRepository userRepository, 
                                    IRoleRepository roleRepository, 
                                    IAbilityRepository abilityRepository)
 {
     _userRepository = userRepository;
     _roleRepository = roleRepository;
     _abilityRepository = abilityRepository;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RegistrationService" /> class.
 /// </summary>
 /// <param name="membershipService">The membership service.</param>
 /// <param name="profileService">The profile service.</param>
 /// <param name="roleRepository">The role repository.</param>
 /// <param name="userRoleRepository">The user role repository.</param>
 public RegistrationService(IMembershipService membershipService, IProfileService profileService,
     IRoleRepository roleRepository, IUserRoleRepository userRoleRepository)
 {
     this.membershipService = membershipService;
     this.profileService = profileService;
     this.roleRepository = roleRepository;
     this.userRoleRepository = userRoleRepository;
 }

 public AccessApplicationService(ITenantRepository tenantRepository, IGroupRepository groupRepository,
     IUserRepository userRepository, IRoleRepository roleRepository)
 {
     this._groupRepository = groupRepository;
     this._roleRepository = roleRepository;
     this._tenantRepository = tenantRepository;
     this._userRepository = userRepository;
 }

        public RoleManager(IRoleRepository roleRepository, IAccountRepository accountRepository)
        {
            if (roleRepository == null) throw new ArgumentNullException("roleRepository");
            if (accountRepository == null) throw new ArgumentNullException("accountRepository");

            m_RoleRepository = roleRepository;
            m_AccountRepository = accountRepository;
        }