internal NMultifileConfiguration(IConfigurationRepository repository,
INSectionMergerRegistry mergerRegistry, IList<string> fileNames)
{
this.repository = repository;
this.mergerRegistry = mergerRegistry;
this.fileNames = fileNames ?? new List<string>();
}
public CompanyService(ICitizenService citizenService, IConfigurationRepository configurationRepository,
IEquipmentRepository equipmentRepository, IProductService productService, IProductRepository productRepository,
ICitizenRepository citizenRepository, ITransactionsService transactionService,
IJobOfferService jobOfferService, ICompanyEmployeeRepository companyEmployeeRepository,
ICompanyRepository companyRepository, IEntityService entityService, ICompanyManagerRepository companyManagerRepository,
IRegionRepository regionRepository, IWarningService warningService, IJobOfferRepository jobOfferRepository,
IEquipmentService equipmentService, IContractService contractService, IWalletService walletService, IPopupService popupService,
IRegionService regionService, ICompanyFinanceSummaryService companyFinanceSummaryService)
{
this.companyRepository = companyRepository;
this.entityService = entityService;
this.companyManagerRepository = companyManagerRepository;
this.jobOfferService = jobOfferService;
this.companyEmployeeRepository = companyEmployeeRepository;
this.citizenRepository = citizenRepository;
this.transactionService = transactionService;
this.equipmentRepository = equipmentRepository;
this.productService = productService;
this.productRepository = productRepository;
this.citizenService = Attach(citizenService);
this.configurationRepository = configurationRepository;
this.regionRepository = regionRepository;
this.warningService = Attach(warningService);
this.jobOfferRepository = jobOfferRepository;
this.equipmentService = Attach(equipmentService);
this.contractService = Attach(contractService);
this.walletService = Attach(walletService);
this.popupService = Attach(popupService);
this.regionService = Attach(regionService);
this.companyFinanceSummaryService = Attach(companyFinanceSummaryService);
}
public Request(IConfigurationRepository configuration, IRelyingPartyRepository relyingPartyRepository,
IDelegationRepository delegationRepository)
{
_configuration = configuration;
RelyingPartyRepository = relyingPartyRepository;
DelegationRepository = delegationRepository;
}
public Request(IConfigurationRepository configuration, IRelyingPartyRepository relyingPartyRepository,
IDelegationRepository delegationRepository)
{
_configuration = configuration;
RelyingPartyRepository = relyingPartyRepository;
DelegationRepository = delegationRepository;
}
public UrlController(IConfigurationManager configurationManager,
IConfigurationRepository configRepository,
IFrontMatterRepository frontMatterRepository,
IMarkupProcessorFactory markupProcessorFactory)
: base(configurationManager)
{
if (configRepository == null)
{
throw new ArgumentNullException("configRepository");
}
if (frontMatterRepository == null)
{
throw new ArgumentNullException("frontMatterRepository");
}
if (markupProcessorFactory == null)
{
throw new ArgumentNullException("markupProcessorFactory");
}
ConfigRepository = configRepository;
FrontMatterRepository = frontMatterRepository;
MarkupProcessorFactory = markupProcessorFactory;
}
public UserManager(IUnitOfWork unitOfWork,
IUserRepository repository,
IMachineRepository machineRepository,
IItemRepository itemRepository,
IUserFileRepository userFileRepository,
IConfigurationRepository configRepository,
IInitRepository initRepository,
ICNCLibUserContext userContext,
ICurrentDateTime currentDate,
IMapper mapper,
IOneWayPasswordProvider passwordProvider,
CallStatisticCache callStatisticCache) : base(unitOfWork, repository, mapper)
{
_unitOfWork = unitOfWork;
_repository = repository;
_machineRepository = machineRepository;
_itemRepository = itemRepository;
_configRepository = configRepository;
_userFileRepository = userFileRepository;
_initRepository = initRepository;
_userContext = userContext;
_currentDate = currentDate;
_mapper = mapper;
_passwordProvider = passwordProvider;
_callStatisticCache = callStatisticCache;
}
private static AuthenticationConfiguration CreateAuthenticationConfiguration(IConfigurationRepository configurationRepository)
{
const string audience = "api/";
var issuerUri = configurationRepository.Global.IssuerUri;
var authenticationConfiguration = new AuthenticationConfiguration
{
ClaimsAuthenticationManager = new ClaimsTransformer(),
RequireSsl = false,
EnableSessionToken = true,
SessionToken = new SessionTokenConfiguration
{
DefaultTokenLifetime = TimeSpan.FromHours(10.0),
EndpointAddress = "/issue/simple",
HeaderName = "Authorization",
Scheme = "Session",
Audience = audience,
IssuerName = issuerUri
}
};
authenticationConfiguration.AddBasicAuthentication(Membership.ValidateUser);
//Client Certificates
authenticationConfiguration.AddClientCertificate(ClientCertificateMode.ChainValidation);
return(authenticationConfiguration);
}
public AdministrationService(
IUserRepository userRepository,
IArticleRepository articleRepository,
IRepository<ReviewTemplate> reviewTemplateRepository,
IArticleReviewerRepository articleReviewerRepository,
IRepository<AttributeDataType> dataTypesRepository,
IRepository<Category> categoryRepository,
IRepository<Degree> degreeRepository,
IRepository<Page> pagesRepository,
IRepository<Language> languageRepository,
IConfigurationRepository configurationRepository,
IRepository<ErrorLog> errorLogRepository
)
{
this.userRepository = userRepository;
this.articleRepository = articleRepository;
this.reviewTemplateRepository = reviewTemplateRepository;
this.articleReviewerRepository = articleReviewerRepository;
this.dataTypesRepository = dataTypesRepository;
this.categoryRepository = categoryRepository;
this.degreeRepository = degreeRepository;
this.pagesRepository = pagesRepository;
this.languageRepository = languageRepository;
this.configurationRepository = configurationRepository;
this.errorLogRepository = errorLogRepository;
callResult = new CallResult();
}
public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository, IClientsRepository clientsRepository, ICodeTokenRepository refreshTokenRepository)
{
UserRepository = userRepository;
ConfigurationRepository = configurationRepository;
ClientsRepository = clientsRepository;
RefreshTokenRepository = refreshTokenRepository;
}
public CartController(ICoffeeRepository coffeeRepo, IConfigurationRepository configRepo)
{
this.coffeeRepo = coffeeRepo;
this.configRepo = configRepo;
this.M = configRepo.Configuration.Where(c => c.Name.Trim() == "m").FirstOrDefault().Value;
this.X = configRepo.Configuration.Where(c => c.Name.Trim() == "x").FirstOrDefault().Value;
}
public OAuth2AuthorizeController(IConfigurationRepository configuration, IClientsRepository client, IRelyingPartyRepository rpRepository, ICodeTokenRepository codeTokenRepository)
{
Configuration = configuration;
Clients = client;
RPRepository = rpRepository;
CodeTokenRepository = codeTokenRepository;
}
public SystemNetEmailService(IConfigurationRepository configurationRepository, ILoggingService loggingService)
{
if (configurationRepository == null) throw new ArgumentNullException("ConfigurationRepository");
if (loggingService == null) throw new ArgumentNullException("LoggingService");
_configurationRepository = configurationRepository;
_loggingService = loggingService;
}
internal NMultifileConfiguration(IConfigurationRepository repository,
INSectionMergerRegistry mergerRegistry, IList <string> fileNames)
{
this.repository = repository;
this.mergerRegistry = mergerRegistry;
this.fileNames = fileNames ?? new List <string>();
}
public AuthenticationController(IProtocolDiscovery defaultProtocolDiscovery, IFederationContext federationContext, IConfigurationRepository configuration)
{
this.protocolDiscovery = defaultProtocolDiscovery;
this.federationContext = federationContext;
this.configuration = configuration;
this.multiProtocolServiceProperties = this.configuration.RetrieveMultiProtocolIssuer();
}
private void InitializeConfiguration()
{
var certificateStore = new CertificateStore(ModuleLogger(nameof(CertificateStore)));
var compressor = new GZipCompressor(ModuleLogger(nameof(GZipCompressor)));
var passwordEncryption = new PasswordEncryption(ModuleLogger(nameof(PasswordEncryption)));
var publicKeyEncryption = new PublicKeyEncryption(certificateStore, ModuleLogger(nameof(PublicKeyEncryption)));
var symmetricEncryption = new PublicKeySymmetricEncryption(certificateStore, ModuleLogger(nameof(PublicKeySymmetricEncryption)), passwordEncryption);
var repositoryLogger = ModuleLogger(nameof(ConfigurationRepository));
var xmlParser = new XmlParser(compressor, ModuleLogger(nameof(XmlParser)));
var xmlSerializer = new XmlSerializer(ModuleLogger(nameof(XmlSerializer)));
configuration = new ConfigurationRepository(certificateStore, new HashAlgorithm(), repositoryLogger);
appConfig = configuration.InitializeAppConfig();
configuration.Register(new BinaryParser(
compressor,
new HashAlgorithm(),
ModuleLogger(nameof(BinaryParser)),
passwordEncryption,
publicKeyEncryption,
symmetricEncryption, xmlParser));
configuration.Register(new BinarySerializer(
compressor,
ModuleLogger(nameof(BinarySerializer)),
passwordEncryption,
publicKeyEncryption,
symmetricEncryption,
xmlSerializer));
configuration.Register(new XmlParser(compressor, ModuleLogger(nameof(XmlParser))));
configuration.Register(new XmlSerializer(ModuleLogger(nameof(XmlSerializer))));
configuration.Register(new FileResourceLoader(ModuleLogger(nameof(FileResourceLoader))));
configuration.Register(new FileResourceSaver(ModuleLogger(nameof(FileResourceSaver))));
configuration.Register(new NetworkResourceLoader(appConfig, new ModuleLogger(logger, nameof(NetworkResourceLoader))));
}
public HomeController(ITeamManagementQueries teamManagementQueries,
IConfigurationRepository configurationRepository)
{
_teamManagementQueries = teamManagementQueries;
_configurationRepository = configurationRepository;
ViewData["inCloud"] = RockPaperAzure.AzureHelper.IsRunningInCloud;
}
public UploadBotController(ITeamManagementCommands teamCommands, IFormsAuthentication formsAuthentication, IConfigurationRepository configurationRepository, MatchStarter matchStarter)
{
_teamCommands = teamCommands;
_formsAuthentication = formsAuthentication;
_configurationRepository = configurationRepository;
_matchStarter = matchStarter;
}
public OAuth2AuthorizeController(IConfigurationRepository configuration, IClientsRepository client, IRelyingPartyRepository rpRepository, ICodeTokenRepository codeTokenRepository)
{
Configuration = configuration;
Clients = client;
RPRepository = rpRepository;
CodeTokenRepository = codeTokenRepository;
}
public MenuViewModel(IConfigurationRepository configuration)
{
this.ShowOAuthClients = configuration.OAuth2.Enabled;
this.ShowOAuthTokens =
configuration.OAuth2.Enabled &&
(configuration.OAuth2.EnableCodeFlow || configuration.OAuth2.EnableResourceOwnerFlow);
}
public ProfileApiController(IUserManagementRepository userManagementRepository, IConfigurationRepository configurationRepository, IRelyingPartyRepository relyingPartyRepository)
{
UserManagementRepository = userManagementRepository;
//ClientRepository = clientRepository;
ConfigurationRepository = configurationRepository;
RelyingPartyRepository = relyingPartyRepository;
}
public ProductService(
IProductRepository productRepository,
ICacheStorage cacheStorage,
IConfigurationRepository configurationRepository,
ILoggingService loggingService)
{
if (productRepository == null)
{
throw new ArgumentNullException("ProductRepository");
}
if (cacheStorage == null)
{
throw new ArgumentNullException("CacheStorage");
}
if (configurationRepository == null)
{
throw new ArgumentException("Configuration");
}
if (loggingService == null)
{
throw new ArgumentException("Logging");
}
this._productRepository = productRepository;
this._cacheStorage = cacheStorage;
this._configurationRepository = configurationRepository;
this._loggingService = loggingService;
}
public BotsController(ITeamManagementCommands teamCommands, ITeamRepository teamRepository, IConfigurationRepository configurationRepository, ILeaderboardRepository leaderboardRepository)
{
_teamCommands = teamCommands;
_teamRepository = teamRepository;
_configurationRepository = configurationRepository;
_leaderboardRepository = leaderboardRepository;
}
public PluginsLogic(IConfigurationRepository configDb, IPluginManager pluginManager, ISafeguardLogic safeguardLogic)
{
_configDb = configDb;
_pluginManager = pluginManager;
_safeguardLogic = safeguardLogic;
_logger = Serilog.Log.Logger;
}
public WebModule(ILogger logger, IContainer container, IConfigurationRepository configuration)
{
_logger = logger;
_container = container;
_configuration = configuration;
_baseAddress = _configuration.GetConfigurationValue("web:endpoint", "");
}
public TestController(
IConfigurationRepository repo,
Services.IWorkCenterService workCenterService
)
{
this.repo = repo;
this.workCenterService = workCenterService;
}
public CustomClaimsProvider(string displayName, IConfigurationRepository configurationRepository)
: base(displayName)
{
this.configurationRepository = configurationRepository;
// TODO: remove this
ServicePointManager.ServerCertificateValidationCallback += delegate { return(true); };
}
/// <summary>
/// Creates a new instance of a <see cref="ResourceGeneratorAnalyzer"/> class.
/// </summary>
/// <param name="repository">The repository.</param>
/// <param name="generator">The generator.</param>
/// <param name="model">The model.</param>
/// <param name="context">The context.</param>
/// <param name="logger">A logger.</param>
public ResourceGeneratorAnalyzer(IConfigurationRepository repository, IResourceGenerator generator, IApplicationModel model, MigrationContext context, ILogger logger)
: base(nameof(ResourceGeneratorAnalyzer), model, context, logger)
{
// Validate and set the member.
_repository = repository ?? throw new ArgumentNullException(nameof(repository));
_generator = generator ?? throw new ArgumentNullException(nameof(generator));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
public ImporterModule(ILogger logger, IConfigurationRepository configuration, IEnumerable <FileTransformationBase> transformations)
{
_logger = logger;
_configuration = configuration;
_directory = configuration.GetConfigurationValue(ConfigurationKeys.ImportDirectory, string.Empty);
_directoryMonitor = new DirectoryMonitor(_logger, _configuration, transformations, _directory);
}
public AddonLogic(IConfigurationRepository configDb, Func <IAddonManager> addonManager, ISafeguardLogic safeguardLogic, IPluginsLogic pluginsLogic)
{
_logger = Serilog.Log.Logger;
_configDb = configDb;
_addonManager = addonManager;
_safeguardLogic = safeguardLogic;
_pluginsLogic = pluginsLogic;
}
public ConfigurationService(ILogger <ConfigurationService> logger,
IConfigurationRepository configurationRepository,
IServiceRepository serviceRepository)
{
_logger = logger;
_configurationRepository = configurationRepository;
_serviceRepository = serviceRepository;
}
public InitialSetupController(IConfigurationRepository configurationRepository, ISignin signin, ITeamManagementCommands teamCommands)
{
_configurationRepository = configurationRepository;
_signin = signin;
_teamCommands = teamCommands;
ViewData["inCloud"] = RockPaperAzure.AzureHelper.IsRunningInCloud;
}
public AppViewModel(IStateMachine<States,Events> stateMachine, CheckEngine engine, IConfigurationRepository repository)
{
StateMachine = stateMachine;
this.repository = repository;
SelectConfigurationCommand = new RelayCommand(SelectConfiguration, () => stateMachine.CanFire(Events.SelectConfigurationSource));
RunChecksCommand = new RelayCommand(RunChecks, () => stateMachine.CanFire(Events.RunChecks));
}
public ApiResourceService(IConfigurationRepository <ApiResource> apiresourceRepository, IConfigurationRepository <ApiScope> apiscopeRepository, IConfigurationRepository <ApiResourceProperty> apipropertyRepository, IConfigurationRepository <ApiSecret> apisecretRepository, IMapper mapper)
{
_apipropertyRepository = apipropertyRepository;
_apisecretRepository = apisecretRepository;
_apiresourceRepository = apiresourceRepository;
_apiscopeRepository = apiscopeRepository;
_mapper = mapper;
}
public ClientService(
IHttpContextAccessor contextAccessor,
IConfigurationRepository <Client> clientRepository,
ISecretGenerator secretGenerator) : base(contextAccessor)
{
_clientRepository = clientRepository;
_secretGenerator = secretGenerator;
}
public GetOptionsByClient(IConfigurationRepository <ClientScope> clientScopeRepository,
IConfigurationRepository <ApiScope> apiScopeRepository,
IConfigurationRepository <IdentityResource> configurationResourceRepo)
{
_clientScopeRepository = clientScopeRepository;
_apiScopeRepository = apiScopeRepository;
_configurationResourceRepo = configurationResourceRepo;
}
public UserAuthenticationService(IUserRepository userRepository, ISessionStateRepository sessionStateRepository, IFormsAuthenticationService formsAuthenticationService, IConfigurationRepository configurationRepository, IAvatar avatar)
{
UserRepository = userRepository;
SessionStateRepository = sessionStateRepository;
FormsAuthenticationService = formsAuthenticationService;
ConfigurationRepository = configurationRepository;
Avatar = avatar;
}
public ConfigurationController(IConfigurationRepository configurationRepository,
ILogger<ConfigurationController> logger,
IAuthenticationService authenticationService)
{
this._configurationRepository = configurationRepository;
this._logger = logger;
this._authenticationService = authenticationService;
}
public ShoutBoxService(IShoutboxMessageRepository shoutboxMessageRepository, ICountryRepository countryRepository,
IShoutboxChannelRepository shoutboxChannelRepository, IConfigurationRepository configurationRepository)
{
this.shoutboxMessageRepository = shoutboxMessageRepository;
this.countryRepository = countryRepository;
this.shoutboxChannelRepository = shoutboxChannelRepository;
this.configurationRepository = configurationRepository;
}
public ApiResourceService(
IHttpContextAccessor contextAccessor,
IConfigurationRepository <ApiResource> apiResourceRepository,
ISecretGenerator secretGenerator) : base(contextAccessor)
{
_apiResourceRepository = apiResourceRepository;
_secretGenerator = secretGenerator;
}
public ConfigurationStoreServiceTests(
IConfigurationRepository repo,
ConfigurationStoreService sut)
{
_fixture = new Fixture();
_repository = repo;
_sut = sut;
}
public PendingCertificatesController(ICertificateRepository certRepo, IConfigurationRepository configRepo, IAuthorizationLogic authorizationLogic, IAuditLogic auditLogic)
{
this.certificateRepository = certRepo;
this.configurationRepository = configRepo;
this.authorizationLogic = authorizationLogic;
this.http = new HttpResponseHandler(this);
this.audit = auditLogic;
}
public OAuth2TokenController(IUserRepository userRepository, IConfigurationRepository configurationRepository,
IClientsRepository clientsRepository, ICodeTokenRepository codeTokenRepository)
{
UserRepository = userRepository;
ConfigurationRepository = configurationRepository;
ClientsRepository = clientsRepository;
CodeTokenRepository = codeTokenRepository;
}
public async Task InvokeAsync(HttpContext httpContext, IConfigurationRepository configurationRepository)
{
var delay = configurationRepository.GetCurrentMillisecondDelay();
await Task.Delay(delay);
await _next(httpContext);
}
public CustomClaimsProvider(string displayName, IConfigurationRepository configurationRepository)
: base(displayName)
{
this.configurationRepository = configurationRepository;
// TODO: remove this
ServicePointManager.ServerCertificateValidationCallback += delegate { return true; };
}
public SenderService(IScheduleRepository scheduleRepository, IConfigurationRepository configurationRepository,
IService <Schedule> scheduleService, IHttpClientWrapper httpClient)
{
this.scheduleRepository = scheduleRepository;
this.httpClient = httpClient;
this.configurationRepository = configurationRepository;
this.scheduleService = scheduleService;
}
public ViewDataService(IConfigurationRepository configurationRepository)
{
if (configurationRepository == null)
{
throw new ArgumentNullException(nameof(configurationRepository));
}
_configurationRepository = configurationRepository;
}
public ConfigurationBase(IConfigurationRepository repository)
{
if (repository == null)
{
throw new ArgumentNullException("配置仓储不可为空![repository]");
}
this.repository = repository;
}
public RouterServerInfoProvider(IConfigurationRepository configRepo, ITaskSchedulerFactory taskSchedulerFactory, IOptions <RouterConfiguration> config, IShamanLogger logger)
{
_configRepo = configRepo;
_taskSchedulerFactory = taskSchedulerFactory;
_config = config;
_logger = logger;
_taskScheduler = _taskSchedulerFactory.GetTaskScheduler();
}
public MovieService(IMovieRepository movieRepository, ICollectionRepository collectionRepository, IGenreRepository genreRepository, IPersonService personService, IConfigurationRepository configurationRepository)
{
_movieRepository = movieRepository;
_collectionRepository = collectionRepository;
_genreRepository = genreRepository;
_personService = personService;
_configurationRepository = configurationRepository;
}
public BestInServiceReportingService(ISqlServerRepository sqlServerRepository)
{
this.configurationRepository = sqlServerRepository.ConfigurationRepository;
this.processControlRepository = sqlServerRepository.ProcessControlRepository;
this.sampleHistoryRepository = sqlServerRepository.SampleHistoryRepository;
this.reportRepository = sqlServerRepository.ReportRepository;
this.sqlServerRepository = sqlServerRepository;
}
public Insert(IConfigurationRepository <Client> clientRepository,
IConfigurationRepository <ClientScope> clientScopeRepository,
IAspValidator validator)
{
_clientRepository = clientRepository;
_clientScopeRepository = clientScopeRepository;
_validator = validator;
}
public static void RegisterRoutes(RouteCollection routes, IConfigurationRepository configuration, IUserRepository userRepository)
{
routes.IgnoreRoute("{resource}.axd/{*pathInfo}");
#region Administration & Configuration
routes.MapRoute(
"InitialConfiguration",
"initialconfiguration",
new { controller = "InitialConfiguration", action = "Index" }
);
//routes.MapRoute(
// "Admin",
// "admin/{action}/{id}",
// new { controller = "Admin", action = "Index", id = UrlParameter.Optional }
//);
//routes.MapRoute(
// "RelyingPartiesAdmin",
// "admin/relyingparties/{action}/{id}",
// new { controller = "RelyingPartiesAdmin", action = "Index", id = UrlParameter.Optional }
//);
//routes.MapRoute(
// "ClientCertificatesAdmin",
// "admin/clientcertificates/{action}/{userName}",
// new { controller = "ClientCertificatesAdmin", action = "Index", userName = UrlParameter.Optional }
//);
//routes.MapRoute(
// "DelegationAdmin",
// "admin/delegation/{action}/{userName}",
// new { controller = "DelegationAdmin", action = "Index", userName = UrlParameter.Optional }
//);
#endregion
#region Main UI
routes.MapRoute(
"ContextCookie",
"contextcookie/{action}",
new { controller = "ContextCookie", action = "Issue", id = UrlParameter.Optional }
);
routes.MapRoute(
"Account",
"account/{action}",
new { controller = "Account", action = "Index", id = UrlParameter.Optional }
);
routes.MapRoute(
"Home",
"{action}",
new { controller = "Home", action = "Index", id = UrlParameter.Optional },
new string[]{"FCSAmerica.McGruff.SecureTokenServer.Controllers"}
);
#endregion
}
public ConfigurationController(IConfigurationRepository repository, string catalog, LoginView view)
{
this._LoginId = view.LoginId.ToLong();
this._UserId = view.UserId.ToInt();
this._OfficeId = view.OfficeId.ToInt();
this._Catalog = catalog;
this.ConfigurationRepository = repository;
}
public SamlTokenService(SecurityTokenServiceConfiguration configuration, IConfigurationRepository configurationRepository, IUserRepository userRepository, IClaimsRepository claimsRepository, IIdentityProviderRepository identityProviderRepository, IClaimsTransformationRulesRepository claimsTransformationRulesRepository)
: base(configuration)
{
UserRepository = userRepository;
ClaimsRepository = claimsRepository;
IdentityProviderRepository = identityProviderRepository;
ClaimsTransformationRulesRepository = claimsTransformationRulesRepository;
ConfigurationRepository = configurationRepository;
}
public AuthenticationController(
IConfigurationRepository configurationRepository,
IUserRepository userRepository,
AuthenticationHelper authenticationHelper)
{
_configurationRepository = configurationRepository;
_userRepository = userRepository;
_authenticationHelper = authenticationHelper;
}
public static void RegisterGlobalFilters(GlobalFilterCollection filters, IConfigurationRepository configuration)
{
//filters.Add(new HandleErrorAttribute());
filters.Add(new ExceptionHandlingAttribute());
filters.Add(new GlobalViewModelFilter());
filters.Add(new SslRedirectFilterAttribute(configuration.Global.HttpsPort));
filters.Add(new InitialConfigurationFilterAttribute());
}
public static void RegisterGlobalFilters(GlobalFilterCollection filters, IConfigurationRepository configuration)
{
filters.Add(new HandleErrorAttribute());
filters.Add(new GlobalViewModelFilter());
if (!configuration.Global.DisableSSL)
{
filters.Add(new SslRedirectFilter(configuration.Global.HttpsPort, configuration.Global.PublicHostName));
}
filters.Add(new InitialConfigurationFilter());
}
public MenuViewModel(IConfigurationRepository configuration)
{
this.ShowIdentityProviders = configuration.WSFederation.Enabled && configuration.WSFederation.EnableFederation;
this.ShowOAuthClients = configuration.OAuth2.Enabled;
this.ShowOAuthTokens =
configuration.OAuth2.Enabled &&
(configuration.OAuth2.EnableCodeFlow || configuration.OAuth2.EnableResourceOwnerFlow);
this.ShowClientCerts = configuration.Global.EnableClientCertificateAuthentication;
this.ShowIdentityDelegation = configuration.WSTrust.Enabled && configuration.WSTrust.EnableDelegation;
}
public EnrichedCustomerService(ICustomerService innerCustomerService, ICacheStorage cacheStorage
, IConfigurationRepository configurationRepository)
{
if (innerCustomerService == null) throw new ArgumentNullException("CustomerService");
if (cacheStorage == null) throw new ArgumentNullException("CacheStorage");
if (configurationRepository == null) throw new ArgumentNullException("ConfigurationRepository");
_innerCustomerService = innerCustomerService;
_cacheStorage = cacheStorage;
_configurationRepository = configurationRepository;
}
public ProxyService(IHmrcDataManipulator dataManipulator, IConfigurationRepository configRepository, IMessageSender messageSender)
{
if (dataManipulator == null) throw new ArgumentNullException(nameof(dataManipulator));
if (configRepository == null) throw new ArgumentNullException(nameof(configRepository));
if (messageSender == null) throw new ArgumentNullException(nameof(messageSender));
this.dataManipulator = dataManipulator;
this.configRepository = configRepository;
this.messageSender = messageSender;
}
