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