public ReverseProxyResponseWriter( IHttpClientFactory httpClientFactory, IHttpContextService httpContextService) { _httpClientFactory = httpClientFactory; _httpContextService = httpContextService; }
public static Data.Blog GetCurrentBlog(this IRepository <Data.Blog> repo, IHttpContextService httpContext) { var host = httpContext.RequestUrl.Host; //TODO use current url return(repo.GetAll().ToArray().Where(b => new Uri(b.AuthoritiveUrl).Host == host).FirstOrDefault()); }
public static Data.Blog GetCurrentBlog(this IRepository<Data.Blog> repo, IHttpContextService httpContext) { var host = httpContext.RequestUrl.Host; //TODO use current url return repo.GetAll().ToArray().Where(b=> new Uri(b.AuthoritiveUrl).Host == host).FirstOrDefault(); }
public GatewayCheckoutService(IWebAPIClient webApiClient, ITranslatorService translatorService, IHttpContextService httpContextService, IRepository repository) { _webApiClient = webApiClient; _translatorService = translatorService; _httpContextService = httpContextService; _repository = repository; }
public RecoveryController( IRepository<Post> postRepository, IRepository<Redirect> redirectRepository, IRepository<BlogTemplate> styleRepository, IRepository<User> userRepository, IRepository<Securable> securableRepository, IRepository<TemporaryUploadedBlogBackup> tempBlogBackupRepo, IRepository<Data.Blog> blogRepository, ISecurityHelper securityHelper, IHttpContextService httpContext) : base(blogRepository, httpContext, securityHelper, userRepository, securableRepository) { _postRepository = postRepository; _redirectRepository = redirectRepository; _styleRepository = styleRepository; _tempBlogBackupRepo = tempBlogBackupRepo; _userRepository = userRepository; _blogRepository = blogRepository; _securityHelper = securityHelper; //Naieve clean of the collection to avoid leaks in long running instances of the application var toDelete = _tempBlogBackupRepo.GetAll().Where(b => b.UploadTime < DateTime.Now.AddHours(-1)).ToArray(); foreach(var toDel in toDelete) { _tempBlogBackupRepo.Delete(toDel); } }
public GetFriendsQuery(IReadOnlyFriendService friendService, IMapper mapper, IHttpContextService httpContextService) { this.friendService = friendService; this.mapper = mapper; this.httpContextService = httpContextService; }
public CoordinatorController(IEntityRepository <ContactEnterprise> enterpriseContactRepository, IEntityRepository <Coordinator> coordinatorRepository, IEntityRepository <Invitation> invitationRepository, IMailler mailler, IAccountService accountService, IEntityRepository <InvitationContactEnterprise> invitationContactRepository, IEntityRepository <Apply> applyRepository, IEntityRepository <Stage> stageRepository, IEntityRepository <Student> studentRepository, IEntityRepository <Interview> interviewRepository, IEntityRepository <StageAgreement> stageAgreementRepository, INotificationService notificationService, IHttpContextService httpContextService, IEntityRepository <Misc> miscRepository) { _enterpriseContactRepository = enterpriseContactRepository; _coordinatorRepository = coordinatorRepository; _invitationRepository = invitationRepository; _mailler = mailler; _accountService = accountService; _invitationContactRepository = invitationContactRepository; _applyRepository = applyRepository; _stageRepository = stageRepository; _studentRepository = studentRepository; _interviewRepository = interviewRepository; _stageAgreementRepository = stageAgreementRepository; _httpContextService = httpContextService; _notificationService = notificationService; _miscRepository = miscRepository; }
public GetMyOffersQuery(IReadOnlyOfferService offerService, IMapper mapper, IHttpContextService httpContextService) { this.offerService = offerService; this.mapper = mapper; this.httpContextService = httpContextService; }
public void ReviewControllerTestInit() { _reviewRepository = Substitute.For <IEntityRepository <Review> >(); _restaurantRepository = Substitute.For <IEntityRepository <Restaurant> >(); _httpContextService = Substitute.For <IHttpContextService>(); _reviewController = new ReviewController(_reviewRepository, _restaurantRepository, _httpContextService); }
public RequestLoggerFactory( IDateTime dateTime, IHttpContextService httpContextService) { _dateTime = dateTime; _httpContextService = httpContextService; }
public SitemapController( IRepository <Post> postRepository, IRepository <Data.Blog> blogRepo, IHttpContextService httpContext) : base(blogRepo, httpContext) { _postRepository = postRepository; }
public void ReviewControllerTestInit() { _reviewRepository = Substitute.For<IEntityRepository<Review>>(); _restaurantRepository = Substitute.For<IEntityRepository<Restaurant>>(); _httpContextService = Substitute.For<IHttpContextService>(); _reviewController = new ReviewController(_reviewRepository, _restaurantRepository, _httpContextService); }
public GetFavoritesOffersQuery(IReadOnlyFavoritesService favoritesService, IMapper mapper, IHttpContextService httpContextService) { this.favoritesService = favoritesService; this.mapper = mapper; this.httpContextService = httpContextService; }
public JsonPathResponseVariableParsingHandler( IHttpContextService httpContextService, ILogger <JsonPathResponseVariableParsingHandler> logger) { _httpContextService = httpContextService; _logger = logger; }
public void CoordinatorControllerTestInit() { coordinatorRepository = Substitute.For <IEntityRepository <Coordinator> >(); invitationRepository = Substitute.For <IEntityRepository <Invitation> >(); enterpriseRepository = Substitute.For <IEntityRepository <ContactEnterprise> >(); applyRepository = Substitute.For <IEntityRepository <Apply> >(); stageRepository = Substitute.For <IEntityRepository <Stage> >(); studentRepository = Substitute.For <IEntityRepository <Student> >(); interviewRepository = Substitute.For <IEntityRepository <Interview> >(); accountService = Substitute.For <IAccountService>(); invitationContactRepository = Substitute.For <IEntityRepository <InvitationContactEnterprise> >(); accountService = Substitute.For <IAccountService>(); httpContextService = Substitute.For <IHttpContextService>(); notificationRepository = Substitute.For <IEntityRepository <Notification> >(); applicationRepository = Substitute.For <IEntityRepository <ApplicationUser> >(); mailler = Substitute.For <IMailler>(); stageAgreementRepository = Substitute.For <IEntityRepository <StageAgreement> >(); notificationService = new NotificationService(applicationRepository, notificationRepository); miscRepository = Substitute.For <IEntityRepository <Misc> >(); coordinatorController = new CoordinatorController(enterpriseRepository, coordinatorRepository, invitationRepository, mailler, accountService, invitationContactRepository, applyRepository, stageRepository, studentRepository, interviewRepository, stageAgreementRepository, notificationService, httpContextService, miscRepository); coordinatorController = new CoordinatorController(enterpriseRepository, coordinatorRepository, invitationRepository, mailler, accountService, invitationContactRepository, applyRepository, stageRepository, studentRepository, interviewRepository, stageAgreementRepository, notificationService, httpContextService, miscRepository); }
public FetchAllReportsQuery(ISupportService supportService, IMapper mapper, IHttpContextService httpContextService) { this.supportService = supportService; this.mapper = mapper; this.httpContextService = httpContextService; }
public RecoveryController( IRepository <Post> postRepository, IRepository <Redirect> redirectRepository, IRepository <BlogTemplate> styleRepository, IRepository <User> userRepository, IRepository <Securable> securableRepository, IRepository <TemporaryUploadedBlogBackup> tempBlogBackupRepo, IRepository <Data.Blog> blogRepository, ISecurityHelper securityHelper, IHttpContextService httpContext) : base(blogRepository, httpContext, securityHelper, userRepository, securableRepository) { _postRepository = postRepository; _redirectRepository = redirectRepository; _styleRepository = styleRepository; _tempBlogBackupRepo = tempBlogBackupRepo; _userRepository = userRepository; _blogRepository = blogRepository; _securityHelper = securityHelper; //Naieve clean of the collection to avoid leaks in long running instances of the application var toDelete = _tempBlogBackupRepo.GetAll().Where(b => b.UploadTime < DateTime.Now.AddHours(-1)).ToArray(); foreach (var toDel in toDelete) { _tempBlogBackupRepo.Delete(toDel); } }
public AccountController(IHttpContextService httpContext, IAccountService accountService, IEntityRepository <ApplicationUser> accountRepository) { _accountRepository = accountRepository; _httpContext = httpContext; _accountService = accountService; }
public FetchGroupsQuery(IReadOnlyGroupService groupService, IMapper mapper, IHttpContextService httpContextService) { this.groupService = groupService; this.mapper = mapper; this.httpContextService = httpContextService; }
public void AccountControllerTestInit() { httpContext = Substitute.For <IHttpContextService>(); accountService = Substitute.For <IAccountService>(); accountRepository = Substitute.For <IEntityRepository <ApplicationUser> >(); accountController = new AccountController(httpContext, accountService, accountRepository); }
public void Initialize() { _httpContext = Substitute.For <IHttpContextService>(); _accountService = Substitute.For <IAccountService>(); _internshipPeriodService = Substitute.For <IInternshipPeriodService>(); _accountController = new AccountController(_httpContext, _accountService, _internshipPeriodService); }
public SitemapController( IRepository<Post> postRepository, IRepository<Data.Blog> blogRepo, IHttpContextService httpContext) : base(blogRepo,httpContext) { _postRepository = postRepository; }
public BaseWithCacheController(IHttpContextService httpContextService, ICacheService cacheService) : base(httpContextService) { _cacheService = cacheService; _loggedUser = _cacheService.Obter <LoggedUser>(CacheKeys.UsuarioLogado); }
public WebSessionManager(ISessionFactory sessionFactory, IHttpContextService httpContextService) { Validate.NotNull(sessionFactory, "sessionFactory"); Validate.NotNull(sessionFactory, "httpContextService"); _sessionFactory = sessionFactory; _httpContextService = httpContextService; }
public void Initialize() { _employeeService = Substitute.For <IEmployeeService>(); _employeeRepository = Substitute.For <IEntityRepository <Employee> >(); _httpContext = Substitute.For <IHttpContextService>(); _accountService = Substitute.For <IAccountService>(); _employeeController = new EmployeeController(_employeeService, _employeeRepository, _httpContext, _accountService); }
public ReviewController(IEntityRepository<Review> reviewRepository, IEntityRepository<Restaurant> restaurantRepository, IHttpContextService httpContextService) { _reviewRepository = reviewRepository; _restaurantRepository = restaurantRepository; _httpContextService = httpContextService; }
public AuthController(IAuthService authService, IHttpContextService httpContextService, ICacheService cacheService) : base(httpContextService) { _AuthService = authService; _cacheService = cacheService; }
public StyleEditorController( IRepository <Style> styleRepo, IRepository <Data.Blog> blogRepo, IHttpContextService httpContext) : base(blogRepo, httpContext) { _styleRepo = styleRepo; _blogRepo = blogRepo; }
public void Setup() { orders = new List<Order>(); var repository = MockRepository.GenerateStub<IRepository<Order>>(); contextService = MockRepository.GenerateStub<IHttpContextService>(); repository.Stub(x => x.GetAll()).Return(orders.AsQueryable()); service = new OrderSearchService(repository, contextService); }
public StyleEditorController( IRepository<Style> styleRepo, IRepository<Data.Blog> blogRepo, IHttpContextService httpContext) : base(blogRepo, httpContext) { _styleRepo = styleRepo; _blogRepo = blogRepo; }
public RenewAccountSessionCommandHandler(IMediator mediator, AuthDataContext repo, ITokenService token, AuthenticateConfig authConfig, IHttpContextService httpContextService) { _token = token ?? throw new ArgumentNullException(nameof(token)); _authConfig = authConfig ?? throw new ArgumentNullException(nameof(authConfig)); _httpContextService = httpContextService ?? throw new ArgumentNullException(nameof(httpContextService)); _repo = repo ?? throw new ArgumentNullException(nameof(repo)); _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator)); }
public NotificationService(IEntityRepository <Notification> notificationRepository, IEntityRepository <Coordinator> coordinatorRepository, IEntityRepository <Employee> employeeRepository, IEntityRepository <ApplicationUser> applicationUserRepository, IHttpContextService httpContext) { _notificationRepository = notificationRepository; _coordinatorRepository = coordinatorRepository; _employeeRepository = employeeRepository; _applicationUserRepository = applicationUserRepository; _httpContext = httpContext; }
public void Initialize() { _companyRepository = Substitute.For <IEntityRepository <Company> >(); _employeeRepository = Substitute.For <IEntityRepository <Employee> >(); _httpContextService = Substitute.For <IHttpContextService>(); _notificationService = Substitute.For <INotificationService>(); _companyController = new CompanyController(_companyRepository, _employeeRepository, _httpContextService, _notificationService); }
public void Initialize() { _studentRepository = Substitute.For <IEntityRepository <Student> >(); _httpContextService = Substitute.For <IHttpContextService>(); _accountService = Substitute.For <IAccountService>(); _studentController = new StudentController(_studentRepository, _accountService, _httpContextService); }
public void AccountControllerTestInit() { _fixture = new Fixture(); _fixture.Customizations.Add(new VirtualMembersOmitter()); _httpContext = Substitute.For<IHttpContextService>(); _userAccountService = Substitute.For<IUserAccountService>(); _accountController = new AccountController(_httpContext, _userAccountService); }
public InterviewController(IEntityRepository <Stagio.Domain.Entities.Apply> applyRepository, IEntityRepository <Stage> stageRepository, IHttpContextService httpContextService, IEntityRepository <Interview> interviewRepository, IEntityRepository <Student> studentRepository, INotificationService notificationService) { _applyRepository = applyRepository; _stageRepository = stageRepository; _httpContextService = httpContextService; _interviewRepository = interviewRepository; _studentRepository = studentRepository; _notificationService = notificationService; }
public AccountController(IHttpContextService httpContext, IUserAccountService userAccountService) { if (httpContext == null) throw new NullReferenceException(); if (userAccountService == null) throw new NullReferenceException(); _httpContext = httpContext; _userAccountService = userAccountService; }
public void Setup() { orders = new List <Order>(); var repository = MockRepository.GenerateStub <IRepository <Order> >(); contextService = MockRepository.GenerateStub <IHttpContextService>(); repository.Stub(x => x.GetAll()).Return(orders.AsQueryable()); service = new OrderSearchService(repository, contextService); }
public EncomendaController(IHttpContextService httpContextService, ICacheService cacheService, IEncomendaService encomendaService, IEmpresaService empresaService) : base(httpContextService, cacheService) { _encomendaService = encomendaService; _empresaService = empresaService; }
public void Initialize() { _employeeRepository = Substitute.For <IEntityRepository <Employee> >(); _httpContextService = Substitute.For <IHttpContextService>(); _coordinatorRepository = Substitute.For <IEntityRepository <Coordinator> >(); _emailService = Substitute.For <IEmailService>(); _inviteCompaniesController = new InviteCompaniesController(_employeeRepository, _emailService, _httpContextService, _coordinatorRepository); }
public PostController( IRepository<Post> postRepository, IRepository<Data.Blog> blogRepo, IRepository<BlogTemplate> blogTemplateRepo, IHttpContextService httpContext) : base(blogRepo, httpContext) { _postRepository = postRepository; _blogTemplateRepo = blogTemplateRepo; _blogRepo = blogRepo; }
public PostController( IRepository<Post> postRepository, IVisitLoggerService visitLogger, IRepository<Data.Blog> blogRepo, IHttpContextService httpContext) : base(blogRepo, httpContext) { _postRepository = postRepository; _visitLogger = visitLogger; _blogRepo = blogRepo; }
public RedirectsController( IRepository<Redirect> redirectRepository, IRepository<Data.Blog> blogRepo, IHttpContextService httpContext, IRepository<User> userRepository, IRepository<Securable> securableRepository, ISecurityHelper securityHelper) : base(blogRepo, httpContext, securityHelper, userRepository, securableRepository) { _redirectRepository = redirectRepository; }
public ReviewController(IEntityRepository<Restaurant> restaurantRepository, IEntityRepository<Writer> writerRepository, IHttpContextService httpContextService) { if (restaurantRepository == null) throw new NullReferenceException(); if (writerRepository == null) throw new NullReferenceException(); if (httpContextService == null) throw new NullReferenceException(); _restaurantRepository = restaurantRepository; _writerRepository = writerRepository; _httpContextService = httpContextService; }
public BlogConfigurationController( IRepository<Data.Blog> blogRepo, IRepository<Securable> securableRepository, IRepository<Data.User> userRepository, ISecurityHelper securityHelper, IHttpContextService httpContext) : base(blogRepo, httpContext,securityHelper,userRepository,securableRepository) { _blogRepo = blogRepo; _securableRepository = securableRepository; _userRepository = userRepository; _securityHelper = securityHelper; }
public TemplateEditorController( IRepository<BlogTemplate> styleRepo, IRepository<Data.Blog> blogRepo, IHttpContextService httpContext, IRepository<User> userRepository, IRepository<Securable> securableRepository, ISecurityHelper securityHelper) : base(blogRepo, httpContext, securityHelper, userRepository, securableRepository) { _styleRepo = styleRepo; _blogRepo = blogRepo; _httpContext = httpContext; }
public CurrentBlogAdminAuthorizeFilter( IRepository<User> userRepository, IRepository<Data.Blog> blogRepository, IRepository<Securable> securableRepository, ISecurityHelper securityHelper, IHttpContextService httpContext) { _userRepository = userRepository; _blogRepository = blogRepository; _securableRepository = securableRepository; _securityHelper = securityHelper; _httpContext = httpContext; }
public BlogBaseController(IRepository<Data.Blog> blogRepo, IHttpContextService httpContext) { _blogRepo = blogRepo; _httpContext = httpContext; var blog = CurrentBlog; ViewBag.BlogName = blog.Name; ViewBag.BlogDescription = blog.Description; ViewBag.Analytics = blog.AnalyticsKey; ViewBag.Twitter = blog.Twitter; ViewBag.Disqus = blog.DisqusShortname; ViewBag.BlogTemplateId = blog.BlogTemplateId; }
public DashboardController( IRepository<Post> postRepo, IRepository<PostModification> postModRepo, IRepository<User> userRepo, IRepository<Securable> securableRepo, IRepository<Data.Blog> blogRepo, ISecurityHelper securityHelper, IHttpContextService httpContext) : base(blogRepo, httpContext) { _postRepo = postRepo; _postModRepo = postModRepo; _userRepo = userRepo; _blogRepo = blogRepo; _securableRepo = securableRepo; _securityHelper = securityHelper; }
public void SetUp() { // you have to be an administrator to access the CMS controller Thread.CurrentPrincipal = new GenericPrincipal(new GenericIdentity("admin"), new[] { "Administrator" }); postageRepository = MockRepository.GenerateStub<IRepository<Postage>>(); orderableService = MockRepository.GenerateStub<IOrderableService<Postage>>(); httpContextService = MockRepository.GenerateStub<IHttpContextService>(); postageController = new PostageController { Repository = postageRepository, OrderableService = orderableService, HttpContextService = httpContextService }; }
public Auditing(IHttpContextService context, IFormsAuthentication formauth, IRepository<Ip2Location> ip2location, IRepository<SessioneDaResettare> sessiontoreset) { if ((_context = context) == null) throw new ArgumentNullException("context"); if ((_sessiontoreset = sessiontoreset) == null) throw new ArgumentNullException("sessiontoreset"); if ((_ip2location = ip2location) == null) throw new ArgumentNullException("ip2location"); if ((_formauth = formauth) == null) throw new ArgumentNullException("formauth"); }
public ManageBaseController( IRepository<Data.Blog> blogRepo, IHttpContextService httpContext, ISecurityHelper securityHelper, IRepository<User> userRepository, IRepository<Securable> securableRepository) : base(blogRepo, httpContext) { var currentUser = userRepository.GetCurrentUser(securityHelper); if (currentUser != null && currentUser.IsAdminOfBlog(CurrentBlog, securableRepository)) { ViewBag.IsBlogAdmin = true; } else { ViewBag.IsBlogAdmin = false; } }
public AccountController( OpenIdMembershipService membershipService, IRepository<User> userRepository, IRepository<Data.Blog> blogRepo, IRepository<Invitation> invitationRepository, IAttacher<User> userAttacher, IAttacher<Securable> securableAttacher, ISecurityHelper securityHelper, IHttpContextService httpContext) : base(blogRepo, httpContext) { _openIdMembership = membershipService; _userRepository = userRepository; _securityHelper = securityHelper; _invitationRepository = invitationRepository; _userAttacher = userAttacher; _securableAttacher = securableAttacher; }
public PostAuthoringController( IRepository<Post> postRepository, IRepository<PostModification> postModificationRepository, IRepository<User> userRepository, IRepository<Redirect> redirectRepository, IRepository<Data.Blog> blogRepository, ISecurityHelper securityHelper, IProvideDateTime dateTime, IHttpContextService httpContext) : base(blogRepository, httpContext) { _postRepository = postRepository; _postModificationRepository = postModificationRepository; _userRepository = userRepository; _redirectRepository = redirectRepository; _blogRepository = blogRepository; _securityHelper = securityHelper; _dateTime = dateTime; }
public PermissionsEditorController( IRepository<User> userRepo, IRepository<Data.Blog> blogRepo, IRepository<Securable> securableRepo, IRepository<Invitation> invitationRepo, ISecurityHelper securityHelper, IInvitationService invitationService, IAttacher<Securable> securableAttacher, IAttacher<Data.Blog> blogAttacher, IHttpContextService httpContext) : base(blogRepo, httpContext, securityHelper, userRepo, securableRepo) { _userRepo = userRepo; _blogRepo = blogRepo; _securableRepo = securableRepo; _invitationRepo = invitationRepo; _securityHelper = securityHelper; _invitationService = invitationService; _blogAttacher = blogAttacher; _securableAttacher = securableAttacher; }
public void AccountControllerTestInit() { _httpContext = Substitute.For<IHttpContextService>(); _userAccountService = Substitute.For<IUserAccountService>(); _accountController = new AccountController(_httpContext, _userAccountService); }
public IndexController(IRepository<Post> postRepo, IRepository<Data.Blog> blogRepo, IHttpContextService httpContext) : base(blogRepo, httpContext) { _postRepo = postRepo; }
public OrderSearchService(IRepository<Order> orderRepository, IHttpContextService httpContextService) { this.orderRepository = orderRepository; this.httpContextService = httpContextService; }
/// <summary> /// Initializes a new instance of the <see cref="NewsController"/> class. /// </summary> /// <exception cref="ArgumentNullException"><paramref name=""/> is <see langword="null" />.</exception> public NewsController(IHttpContextService context) { if (context == null) throw new ArgumentNullException("context"); this.context = context; }
public UserService(IHttpContextService context, ILinqRepository<Parent> parentRepository, ILinqRepository<User> userRepository) { this.context = context; this.parentRepository = parentRepository; this.userRepository = userRepository; }