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;
}
