public static AccountController GetAccountControllerForConnectedUser(IMemberRepository memberRepository) { var accountController = new AccountController(null, memberRepository, null, new TestSessionRegistry()); ConnectController(accountController); return accountController; }
public Mapper() { _assemblyRepository = new AssemblyRepository(); _typeRepository = new TypeRepository(_assemblyRepository); _memberRepository = new MemberRepository(_typeRepository); _modelCreator = new ModelCreator(_typeRepository, _memberRepository); }
public BorrowController(IBorrowerRepository borrowerRepository, IMemberRepository memberRepository, IPublicationRepository publicationRepository, IDataContext dataContext) : base(dataContext) { _borrowerRepository = borrowerRepository; _memberRepository = memberRepository; _publicationRepository = publicationRepository; }
public MemberController(IMemberRepository repository, IGraceConfigService graceConfigService, IGraceSessionService graceSessionService, IGraceGlobalCacheService graceGlobalCacheService) { _repository = repository; _graceConfigService = graceConfigService; _graceSessionService = graceSessionService; _graceGlobalCacheService = graceGlobalCacheService; }
public MultiMemberInsurancePremium(IPolicyRepository policyRepository, IMemberRepository memberRepository, IMultiMemberPremiumCalculator calculator) { this.policyRepository = policyRepository; this.memberRepository = memberRepository; this.calculator = calculator; }
public MemberModule(IMemberRepository memberRepository) : base("smack/members") { _memberRepository = memberRepository; Get["/"] = x => GetAll(); Post["/"] = x => SavNewMember(); }
private RoundController(IDalContext context) { _tournaments = context.Tournaments; _members = context.Members; _rounds = context.Rounds; _tables = context.Tables; }
public InfoController(IMemberRepository memberRepository, IMongoConnectionHandler mongoConnectionHandler, ICommentRepository commentRepository, IInfoRepository infoRepository) { _memberRepo = memberRepository; _commentRepo = commentRepository; _infoRepo = infoRepository; _mongoConnectionHandler = mongoConnectionHandler; }
public LoanService(IBookRepository bookRepository, IMemberRepository memberRepository, IUnitOfWork unitOfWork) { _bookRepository = bookRepository; _memberRepository = memberRepository; _unitOfWork = unitOfWork; }
public DivisionModule(IDivisionRepository divisionRepository, IMemberRepository memberRepository) : base("smack/divisions") { _divisionRepository = divisionRepository; _memberRepository = memberRepository; Get["/"] = x => GetAllDivisions(); Get["/{id}/members"] = x => GetMembers(x.id); }
public void SetUp() { _tempDataRepository = new FakeTempDataRepository(); _gatherMemberInfoView = new FakeGatherMemberInfoView(); _nationalFitnessGateway = new FakeNationalFitnessGateway(); _ccProcessingGateway = new FakeCCProcessingGateway(); _memberRepository = new FakeMemberRepository(); _renewMembershipView = new FakeRenewMembershipView(); }
public TasksService(IDbHelper helper, IProjectRepository projectRepo, IGenericRepository genericRepo, IMemberRepository memberRepo, ITasksRepository taskRepo, INotificationsService notificationService) { _helper = helper; _projectRepo = projectRepo; _genericRepo = genericRepo; _memberRepo = memberRepo; _taskRepo = taskRepo; _notificationService = notificationService; }
public static ProblemController GetProblemController( IMemberRepository memberRepository, IProblemService problemService, IProblemRepository problemRepository) { var problemController = new ProblemController(memberRepository, problemService, problemRepository, new TestSessionRegistry()); problemController.InjectFakeContext(); problemController.ConnectUser(); return problemController; }
public static void SetUp(TestContext context) { _unitOfWork = new UnitOfWork(); _factory = new MemberFactory(); _repository = _unitOfWork.MemberRepository; _decorator = new MemberDecorator(_factory, _repository); _email = "*****@*****.**"; _member = _decorator.CreateMember(_email); }
public ModelCreator(ITypeRepository typeRepository, IMemberRepository memberRepository) { _types.Push(TypeKey.None); _methods.Push(MethodKey.None); _properties.Push(PropertyKey.None); _fields.Push(FieldKey.None); _events.Push(EventKey.None); _typeRepository = typeRepository; _memberRepository = memberRepository; }
public AccountController( IMembershipService membershipService, IMemberRepository memberRepository, IAccountRelyingParty relyingParty, ISessionRegistry sessionRegistry) : base(sessionRegistry) { _membershipService = membershipService; _memberRepository = memberRepository; _relyingParty = relyingParty; }
public ProblemController( IMemberRepository memberRepository, IProblemService problemService, IProblemRepository problemRepository, ISessionRegistry sessionRegistry) : base(sessionRegistry) { _memberRepository = memberRepository; _problemService = problemService; _problemRepository = problemRepository; }
public LibraryService(IBookTitleRepository bookTitleRepository, IBookRepository bookRepository, IMemberRepository memberRepository, IUnitOfWork unitOfWork) { _uow = unitOfWork; _memberRepository = memberRepository; _bookTitleRepository = bookTitleRepository; _bookRepository = bookRepository; _loanService = new LoanService(_bookRepository, _memberRepository, _uow); }
public RenewMembershipPresenter(ITempDataRepository tempDataRepository, INationalFitnessGateway nationalFitnessGateway, ICCProcessingGateway ccProcessingGateway, IMemberRepository memberRepository, IRenewMembershipView renewMembershipView) { _tempDataRepository = tempDataRepository; _nationalFitnessGateway = nationalFitnessGateway; _ccProcessingGateway = ccProcessingGateway; _memberRepository = memberRepository; _renewMembershipView = renewMembershipView; _renewMembershipView.Initialize += new EventHandler(_renewMembershipView_Initialize); _renewMembershipView.RenewMembership += new EventHandler(_renewMembershipView_RenewMembership); }
public OfferAssignmentService( IMemberRepository memberRepository, IOfferTypeRepository offerTypeRepository, IOfferValueCalculator offerValueCalculator, IOfferRepository offerRepository ) { _memberRepository = memberRepository; _offerTypeRepository = offerTypeRepository; _offerValueCalculator = offerValueCalculator; _offerRepository = offerRepository; }
public RegisterController( IMemberRepository memberManager, ICompanyRepository companyManager, IUnitOfWorkManager unitOfWorkManager, IRoofTypeAppService roofTypeService, IServiceTypeAppService serviceTypeService) { _memberManager = memberManager; _companyManager = companyManager; _unitOfWorkManager = unitOfWorkManager; _roofTypeService = roofTypeService; _serviceTypeService = serviceTypeService; }
public WebimModel() { historyRepository = new HistoryRepository(); settingRepository = new SettingRepository(); roomRepository = new RoomRepository(); memberRepository = new MemberRepository(); blockRepository = new BlockedRepository(); visitorRepository = new VisitorRepository(); }
/// <summary> /// Initializes a new instance of the <see cref="MemberModule" />. /// </summary> /// <param name="repository">The member's repository</param> public MemberModule(IApplication application, IMemberRepository repository) : base(application, _ModulePath) { this._Repository = repository; // Define a route for urls "/members/{id}" which will returns the member matching the specified slug this.Get["/{id}"] = parameters => { return GetMember(parameters.id); }; // Bind the HTTP GET verb to the ListMembers method this.Get[""] = ListMembers; }
public ValidationRules(IBandRepository bandRepository, IMemberRepository memberRepository, ISongRepository songRepository, ISetlistRepository setListRepository, IGigRepository gigRepository, IInstrumentRepository instrumentRepository) { _bandRepository = bandRepository; _memberRepository = memberRepository; _songRepository = songRepository; _setListRepository = setListRepository; _gigRepository = gigRepository; _instrumentRepository = instrumentRepository; }
public MembersController(ILog logger, IMemberRepository repo, UrlHelperWrapper urlHelperWrapper) : base() { UrlHelperWrapper = urlHelperWrapper; if (_memberRepo == null) { _memberRepo = repo; _defaultMembers = repo.GetAll().ToList(); } if (_logger == null) { _logger = logger; } }
public BandsController( IUserRepository userRepository, IBandRepository bandRepository, ISongRepository songRepository, IMemberRepository memberRepository, IValidationRules validationRules, IAccount account) { _userRepository = userRepository; _bandRepository = bandRepository; _songRepository = songRepository; _memberRepository = memberRepository; _validationRules = validationRules; var currentUserName = GetCurrentSessionUser(); if (currentUserName.Length > 0) _currentUser = account.GetUserByUserName(currentUserName); _common = new CommonSong(account, currentUserName); }
public MemberService(IMemberRepository memberRepository, IMemberSearchFilterRepository memberSearchFilterRepository, ISearchQueryService searchQueryService) { if (memberRepository == null) { throw new ArgumentNullException("memberRepository"); } if (memberSearchFilterRepository == null) { throw new ArgumentNullException("memberSearchFilterRepository"); } if (searchQueryService == null) { throw new ArgumentNullException("searchQueryService"); } this.memberRepository = memberRepository; this.memberSearchFilterRepository = memberSearchFilterRepository; this.searchQueryService = searchQueryService; }
public MembersController(IMemberRepository repo) { _memberRepo = repo; }
public MembermoveViewComponent(IConfiguration configuration, IMemberRepository MemberRepository) { IMR = MemberRepository; IMR.constr = configuration.GetConnectionString("SqlConn"); config = configuration; }
public MemberService(IMemberRepository repository) => _repository = repository;
public MemberService() { _memberRepository = new MemberRepository(); }
public CartController(IMemberRepository repo, Cart cartService) { repository = repo; cart = cartService; }
public void SetUp() { memberRepository = MockRepository.GenerateMock<IMemberRepository>(); }
public MembersController(IMemberRepository memberRepository, ICommonRepository commonRepository, ILogger logger) { _repository = memberRepository; _logger = logger; _commonRepository = commonRepository; }
public DemoteMemberCommand(Guid id, IMemberRepository repository) { Id = id; Member = repository.GetForGuildOperationsAsync(id).Result; }
public MemberService(IMapper mapper, IMemberRepository memberRepository) { _mapper = mapper; _memberRepository = memberRepository; }
/// <summary> /// default constructor for product. /// </summary> //public MembersController() : this(new MemberRepository()) //{ // // its not good, because use DI. // // comment out, change to use di container (Ninject) //} /// <summary> /// constructor for test. /// </summary> /// <param name="rep"></param> public MembersController(IMemberRepository rep) { // is it okay for that test code have remained in production code? _rep = rep; }
public MemberService(IMemberRepository memberRepo) { _memberRepo = memberRepo; }
public MemberService(IMemberRepository memberRepository) { _memberRepository = memberRepository; }
public UpdateWalletMembersCommandHandler(IBetRepository betRepository, IMemberRepository memberRepository) { _betRepository = betRepository; _memberRepository = memberRepository; }
public MemberService(IDbContextScopeFactory dbContextScopeFactory, IMemberRepository memberRepository) : base(dbContextScopeFactory) { _memberRepository = memberRepository; }
public MemberController(IMemberRepository memberRepo) { _memberRepo = memberRepo; }
public HomeController(IMemberRepository memberRepository, IHostingEnvironment hostingEnvironment) { _memberRepository = memberRepository; this.hostingEnvironment = hostingEnvironment; }
public MessageController(IMemberRepository repo) { memberRepo = repo; }
public async Task <List <Member> > Members([Inject] IMemberRepository memberRepository) { var members = await memberRepository.GetMembersForTeam(_dto.Id); return(members.ConvertAll(Member.FromDto)); }
public PictureController(IConstantRepository ConstantParam, IMinistryRepository MinistryParam, IPictureRepository PictureParam, IStoryRepository StoryParam, IMemberRepository MemberParam) { ConstantRepository = ConstantParam; MinistryRepository = MinistryParam; PictureRepository = PictureParam; StoryRepository = StoryParam; MemberRepository = MemberParam; //security ViewBag.Supervisor = false; int memberID = Convert.ToInt16(System.Web.HttpContext.Current.Session["personID"]); if (memberID > 0) { if (MembershipRepositroy.IsUser(memberID)) { user user = MembershipRepositroy.GetUserByID(memberID); if ((user.role.Name == "WebMaster") || (user.role.Name == "Pastor") || (user.role.Name == "Admin") || (user.role.Name == "Admin2")) //creator access { ViewBag.Supervisor = true; } if (user.role.Name == "WebMaster") //creator access { ViewBag.WebMaster = true; } if (user.role.Name == "Officer") //creator access { ViewBag.Supervisor2 = true; } } } }
public MemberControllerService(IMemberService memberService, IMemberRepository memberRepository) { this.memberService = memberService; this.memberRepository = memberRepository; }
//messageRepo & memberRepo public ChannelsController(UserManager <User> userManager, IChannelRepository channelRepository, IMessageRepository messageRepository, IMemberRepository memberRepository, IHubContext <NotifyHub, ITypedHubClient> hubContext) { this.userManager = userManager; this.channelRepository = channelRepository; this.messageRepository = messageRepository; this.memberRepository = memberRepository; this.hubContext = hubContext; }
public MemberDetailsViewModel(IEventAggregator eventAggregator, IMessageDialogService messageDialogService, IMemberRepository memberRepository) : base(eventAggregator, messageDialogService) { _memberRepository = memberRepository; }
public static IActorRef CreateInstance(ActorSystem actorSystem, IMemberRepository memberRepository) { return(actorSystem.ActorOf(Props.Create(typeof(MembershipActor), memberRepository), "Membership")); }
//IScoresRepository repository; public ScoresController(IScoresRepository repository, IMemberRepository members) { ViewData["Message"] = "Baby Leader Board"; scoresRepository = repository; membersRepository = members; }
public TasksService(IMapper mapper, ITaskRepository taskRepository, IMemberRepository memberRepository) { _mapper = mapper; _taskRepository = taskRepository; _memberRepository = memberRepository; }
public MembersController(IMemberRepository memberRepository) { _memberRepository = memberRepository; }
public UnitOfWorkMockBuilder SetupRepository(IMemberRepository repository) { _mock.SetupGet(x => x.Members).Returns(repository); return(this); }
public MemberHandler(IMemberRepository memberRepository, IUnitOfWork unitOfWork) { _memberRepository = memberRepository; _unitOfWork = unitOfWork; }
public UserService(IUnitOfWork unitOfWork, IUserRepository userRepository, IMemberEntityRepository memberEntityRepository, IRoleRepository roleRepository, IUserRoleRepository userRoleRepository, IMemberRepository memberRepository) : base(unitOfWork, userRepository) { try { _unitOfWork = unitOfWork; _userRepository = userRepository; _memberEntityRepository = memberEntityRepository; _roleRepository = roleRepository; _userRoleRepository = userRoleRepository; _memberRepository = memberRepository; } catch (Exception ex) { throw ex; } }
/// <summary> ///In constructor, we can get needed classes/interfaces. ///They are sent here by dependency injection system automatically. /// </summary> public MemberAppService(IMemberRepository memberRepository, ICreditsHeroConnect creditsHeroConnect) { _memberRepository = memberRepository; _creditsHeroConnect = creditsHeroConnect; }
public MemberManager(IMemberRepository memberRepository) { _memberRepository = memberRepository; }
public MemberController(IMemberRepository memberRepository) { _memberRepository = (MemberRepository)memberRepository; }
public TeamsSubscription(IMemberRepository memberRepository) { _memberRepository = memberRepository; }