public void Subscribe(IHttpService service, HttpMessagePipe pipe)
{
Ensure.NotNull(service, "service");
Ensure.NotNull(pipe, "pipe");
SubscribeCore(service, pipe);
}
public ArasHttpConnection(IHttpService service, string innovatorServerUrl)
{
_service = service;
this.Compression = CompressionType.none;
_factory = new ElementFactory(_context);
if (innovatorServerUrl.EndsWith("Server/InnovatorServer.aspx", StringComparison.OrdinalIgnoreCase))
{
innovatorServerUrl = innovatorServerUrl.Substring(0, innovatorServerUrl.Length - 20);
}
else if (innovatorServerUrl.EndsWith("/Server", StringComparison.OrdinalIgnoreCase)
|| innovatorServerUrl.EndsWith("/Server/", StringComparison.OrdinalIgnoreCase))
{
innovatorServerUrl += (innovatorServerUrl.EndsWith("/") ? "" : "/");
}
else
{
innovatorServerUrl += (innovatorServerUrl.EndsWith("/") ? "" : "/") + "Server/";
}
this._innovatorServerBaseUrl = new Uri(innovatorServerUrl);
this._innovatorServerUrl = new Uri(this._innovatorServerBaseUrl, "InnovatorServer.aspx");
this._innovatorClientBin = new Uri(this._innovatorServerBaseUrl, "../Client/cbin/");
_vaultConn = new ArasVaultConnection(this);
}
internal ProxyServerConnection(IHttpService service, Endpoints endpoints)
{
_service = service;
_endpoints = endpoints;
_timer = new System.Timers.Timer();
_timer.Elapsed += _timer_Elapsed;
}
public NetkanTransformer(
IHttpService http,
IFileService fileService,
IModuleService moduleService,
string githubToken,
bool prerelease
)
{
_transformers = new List<ITransformer>
{
new MetaNetkanTransformer(http),
new KerbalstuffTransformer(new KerbalstuffApi(http)),
new GithubTransformer(new GithubApi(githubToken), prerelease),
new HttpTransformer(),
new JenkinsTransformer(),
new InternalCkanTransformer(http, moduleService),
new AvcTransformer(http, moduleService),
new VersionEditTransformer(),
new ForcedVTransformer(),
new EpochTransformer(),
new VersionedOverrideTransformer(),
new DownloadSizeTransformer(http, fileService),
new GeneratedByTransformer(),
new OptimusPrimeTransformer(),
new StripNetkanMetadataTransformer(),
new PropertySortTransformer()
};
}
public NetkanTransformer(
IHttpService http,
IFileService fileService,
IModuleService moduleService,
string githubToken,
bool prerelease
)
{
_transformers = InjectVersionedOverrideTransformers(new List<ITransformer>
{
new MetaNetkanTransformer(http),
new SpacedockTransformer(new SpacedockApi(http)),
new GithubTransformer(new GithubApi(githubToken), prerelease),
new HttpTransformer(),
new JenkinsTransformer(http),
new InternalCkanTransformer(http, moduleService),
new AvcTransformer(http, moduleService),
new VersionEditTransformer(),
new ForcedVTransformer(),
new EpochTransformer(),
// This is the "default" VersionedOverrideTransformer for compatability with overrides that don't
// specify a before or after property.
new VersionedOverrideTransformer(before: new string[] { null }, after: new string[] { null }),
new DownloadAttributeTransformer(http, fileService),
new GeneratedByTransformer(),
new OptimusPrimeTransformer(),
new StripNetkanMetadataTransformer(),
new PropertySortTransformer()
});
}
public GoogleReaderClientLogin(string username, string password, IHttpService httpService, IUriBuilder urlBuilder)
{
Username = username;
Password = password;
_httpService = httpService;
_urlBuilder = urlBuilder;
}
protected override void SubscribeCore(IHttpService service)
{
Ensure.NotNull(service, "service");
service.RegisterAction(new ControllerAction("/stats", HttpMethod.Get, Codec.NoCodecs, SupportedCodecs), OnGetFreshStats);
service.RegisterAction(new ControllerAction("/stats/{*statPath}", HttpMethod.Get, Codec.NoCodecs, SupportedCodecs), OnGetFreshStats);
}
public CkanValidator(Metadata netkan, IHttpService downloader, IModuleService moduleService)
{
_validators = new List<IValidator>
{
new IsCkanModuleValidator(),
new MatchingIdentifiersValidator(netkan.Identifier),
new InstallsFilesValidator(downloader, moduleService)
};
}
protected override void SubscribeCore(IHttpService service, HttpMessagePipe pipe)
{
_singleNodeWeb.RegisterControllerActions(service);
_commonWeb.RegisterControllerActions(service);
_singleNodeJs.RegisterControllerActions(service);
RegisterRedirectAction(service, "", "/web/home.htm");
RegisterRedirectAction(service, "/web", "/web/home.htm");
RegisterRedirectAction(service, "/web/projections", "/web/projections.htm");
}
protected override void SubscribeCore(IHttpService service)
{
service.RegisterControllerAction(new ControllerAction("/admin/halt", HttpMethod.Post, Codec.NoCodecs, SupportedCodecs),
OnPostHalt);
service.RegisterControllerAction(new ControllerAction("/admin/shutdown", HttpMethod.Post, Codec.NoCodecs, SupportedCodecs),
OnPostShutdown);
service.RegisterControllerAction(new ControllerAction("/admin/scavenge", HttpMethod.Post, Codec.NoCodecs, SupportedCodecs),
OnPostScavenge);
}
protected override void SubscribeCore(IHttpService service, HttpMessagePipe pipe)
{
service.RegisterControllerAction(new ControllerAction("/streams/{stream}/event/{version}?resolve={resolve}",
HttpMethod.Get,
Codec.NoCodecs,
SupportedCodecs,
DefaultResponseCodec),
OnGetRead);
}
protected override void SubscribeCore(IHttpService service, HttpMessagePipe pipe)
{
service.RegisterControllerAction(new ControllerAction("/shutdown",
HttpMethod.Post,
SupportedCodecs,
SupportedCodecs,
DefaultResponseCodec),
OnPostShutdown);
}
public void RegisterControllerActions(IHttpService service)
{
var pattern = _localWebRootPath + "/{*remaining_path}";
_logger.Trace("Binding MiniWeb to {0}", pattern);
service.RegisterAction(new ControllerAction(pattern,
HttpMethod.Get,
Codec.NoCodecs,
new ICodec[] { Codec.ManualEncoding }),
OnStaticContent);
}
public HomeMaticXmlApi(Ccu ccu, bool isDemoMode = false, string owner = null)
{
this.Ccu = ccu;
this.IsDemoMode = isDemoMode;
_HttpService = new HttpService();
if (IsDemoMode)
_HttpService = new MockedHttpService(owner);
}
protected override void SubscribeCore(IHttpService service)
{
Register(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Get, GetSubscriptionInfo, Codec.NoCodecs, DefaultCodecs);
Register(service, "/subscriptions/{stream}", HttpMethod.Get, GetSubscriptionInfoForStream, Codec.NoCodecs, DefaultCodecs);
Register(service, "/subscriptions", HttpMethod.Get, GetAllSubscriptionInfo, Codec.NoCodecs, DefaultCodecs);
Register(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Put, PutSubscription, DefaultCodecs, DefaultCodecs);
Register(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Post, PostSubscription, DefaultCodecs, DefaultCodecs);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Delete, DeleteSubscription);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}/replayParked", HttpMethod.Post, ReplayParkedMessages);
}
protected override void SubscribeCore(IHttpService service)
{
_clusterNodeWeb.RegisterControllerActions(service);
RegisterRedirectAction(service, "", "/web/home.htm");
RegisterRedirectAction(service, "/web", "/web/home.htm");
service.RegisterAction(
new ControllerAction("/sys/subsystems", HttpMethod.Get, Codec.NoCodecs, new ICodec[] { Codec.Json }),
OnListNodeSubsystems);
}
public RatingResult GetRatingWithCache(string imdbId, IHttpService httpService, IFileSystem fileSystem)
{
RatingResult result = AttemptReadFromCache(imdbId, fileSystem);
if (result == null)
{
result = base.GetRatingFromApi(imdbId, httpService);
WriteResultToCache(imdbId, result, fileSystem);
}
return result;
}
public DataClient (IMapperService mapperService,
IConnectivityService connectivityService,
ISerializerService serializerService,
IHttpService httpService,
IAppConfig appConfig)
{
_mapperService = mapperService.ThrowIfNull ("mapperService");
_connectivityService = connectivityService.ThrowIfNull ("connectivityService");
_serializerService = serializerService.ThrowIfNull ("serializerService");
_httpService = httpService.ThrowIfNull ("httpService");
_appConfig = appConfig.ThrowIfNull ("appConfig");
}
internal EndpointMonitor( string endpointUrl, double intervalInMilliseconds, IHttpService http, ILogger log )
{
url = endpointUrl;
interval = intervalInMilliseconds;
httpService = http;
logger = log;
timer = new Timer( interval )
{
AutoReset = false // The timer will only fire once and must be restarted.
};
timer.Elapsed += Timer_Elapsed;
}
protected override void SubscribeCore(IHttpService service)
{
Register(service, "/test1", Test1Handler);
Register(service, "/test-anonymous", TestAnonymousHandler);
Register(service, "/test-encoding/{a}?b={b}", TestEncodingHandler);
Register(service, "/test-encoding-reserved-%20?b={b}", (manager, match) => TestEncodingHandler(manager, match, "%20"));
Register(service, "/test-encoding-reserved-%24?b={b}", (manager, match) => TestEncodingHandler(manager, match, "%24"));
Register(service, "/test-encoding-reserved-%25?b={b}", (manager, match) => TestEncodingHandler(manager, match, "%25"));
Register(service, "/test-encoding-reserved- ?b={b}", (manager, match) => TestEncodingHandler(manager, match, " "));
Register(service, "/test-encoding-reserved-$?b={b}", (manager, match) => TestEncodingHandler(manager, match, "$"));
Register(service, "/test-encoding-reserved-%?b={b}", (manager, match) => TestEncodingHandler(manager, match, "%"));
}
protected override void SubscribeCore(IHttpService service, HttpMessagePipe pipe)
{
Ensure.NotNull(service, "service");
Ensure.NotNull(pipe, "pipe");
service.RegisterControllerAction(new ControllerAction("/stats/{*statPath}",
HttpMethod.Get,
Codec.NoCodecs,
SupportedCodecs,
DefaultResponseCodec),
OnGetFreshStats);
}
public void Subscribe(IHttpService service, HttpMessagePipe pipe)
{
Ensure.NotNull(service, "service");
Ensure.NotNull(pipe, "pipe");
service.RegisterControllerAction(new ControllerAction("/ping",
HttpMethod.Get,
Codec.NoCodecs,
SupportedCodecs,
DefaultResponseCodec),
OnGetPing);
}
private static void RegisterRedirectAction(IHttpService service, string fromUrl, string toUrl)
{
service.RegisterControllerAction(
new ControllerAction(
fromUrl,
HttpMethod.Get,
Codec.NoCodecs,
new ICodec[] { Codec.ManualEncoding }, Codec.ManualEncoding),
(http, match) => http.Manager.Reply(
"Moved", 302, "Found", "text/plain",
new[]
{
new KeyValuePair<string, string>(
"Location", new Uri(match.BaseUri, toUrl).AbsoluteUri)
}, Console.WriteLine));
}
protected override void SubscribeCore(IHttpService service)
{
Register(service, "/subscriptions", HttpMethod.Get, GetAllSubscriptionInfo, Codec.NoCodecs, DefaultCodecs);
Register(service, "/subscriptions/{stream}", HttpMethod.Get, GetSubscriptionInfoForStream, Codec.NoCodecs, DefaultCodecs);
Register(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Put, PutSubscription, DefaultCodecs, DefaultCodecs);
Register(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Post, PostSubscription, DefaultCodecs, DefaultCodecs);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Delete, DeleteSubscription);
Register(service, "/subscriptions/{stream}/{subscription}", HttpMethod.Get, GetNextNMessages, Codec.NoCodecs, AtomCodecs);
Register(service, "/subscriptions/{stream}/{subscription}?embed={embed}", HttpMethod.Get, GetNextNMessages, Codec.NoCodecs, AtomCodecs);
Register(service, "/subscriptions/{stream}/{subscription}/{count}?embed={embed}", HttpMethod.Get, GetNextNMessages, Codec.NoCodecs, AtomCodecs);
Register(service, "/subscriptions/{stream}/{subscription}/info", HttpMethod.Get, GetSubscriptionInfo, Codec.NoCodecs, DefaultCodecs);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}/ack/{messageid}", HttpMethod.Post, AckMessage);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}/nack/{messageid}?action={action}", HttpMethod.Post, NackMessage);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}/ack?ids={messageids}", HttpMethod.Post, AckMessages);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}/nack?ids={messageids}&action={action}", HttpMethod.Post, NackMessages);
RegisterUrlBased(service, "/subscriptions/{stream}/{subscription}/replayParked", HttpMethod.Post, ReplayParkedMessages);
}
public GenreRepository(IHttpService httpService)
{
this.httpService = httpService;
}
public ImportDataService(IHttpService httpService)
{
this.httpService = httpService;
}
public InternalCkanTransformer(IHttpService http, IModuleService moduleService)
{
_http = http;
_moduleService = moduleService;
}
public AuthService(IUserRepository userService, IHttpService httpService)
{
this.userRepository = userService;
this.httpService = httpService;
}
public AccountService(IHttpService httpService)
{
this._httpService = httpService;
}
public EventDetailsPictureGalleryViewModel(IMvxLogProvider logProvider, IMvxNavigationService navigationService, IHttpService networkService) : base(logProvider, navigationService)
{
_networkService = networkService;
OpenDocumentCommand = new MvxAsyncCommand <File>(async(f) => await OpenDocument(f));
}
public UserService(IHttpService httpService)
{
_httpService = httpService;
}
protected abstract void SubscribeCore(IHttpService service);
protected void RegisterTextBody(
IHttpService service, string uriTemplate, string httpMethod, Action<HttpEntityManager, string> action)
{
Register(
service, uriTemplate, httpMethod, (http, match) => http.ReadTextRequestAsync(action, LogError),
_defaultCodecs, _defaultCodecs);
}
protected void RegisterUrlBased(
IHttpService service, string uriTemplate, string httpMethod, Action<HttpEntityManager, UriTemplateMatch> action)
{
Register(service, uriTemplate, httpMethod, action, Codec.NoCodecs, _defaultCodecs);
}
public HomeController(IEncryptionService encryptionService, IHttpService httpService)
{
_encryptionService = encryptionService ?? throw new ArgumentNullException(nameof(encryptionService));
_httpService = httpService ?? throw new ArgumentNullException(nameof(httpService));
}
public TokenService(IHttpService httpService_)
{
httpService = httpService_;
}
public Snapshooter(string sessionId, SnapshooterSettings settings, IHttpService httpService)
{
this.Settings = settings;
this.SessionId = sessionId;
this.HttpService = httpService;
}
public void Subscribe(IHttpService service)
{
Ensure.NotNull(service, "service");
SubscribeCore(service);
}
public WeatherForecastController(MicroserviceConfiguration configuration, IHttpService httpService)
{
_configuration = configuration;
_httpService = httpService;
}
protected abstract void SubscribeCore(IHttpService service);
public PastebinService(ILogger <PastebinService> log, IOptions <PastbinSettings> config, IHttpService http)
{
_http = http;
_log = log;
_config = config.Value;
}
protected void Register(IHttpService service, string uriTemplate, string httpMethod,
Action <HttpEntityManager, UriTemplateMatch> handler, ICodec[] requestCodecs, ICodec[] responseCodecs, AuthorizationLevel requiredAuthorizationLevel)
{
service.RegisterAction(new ControllerAction(uriTemplate, httpMethod, requestCodecs, responseCodecs, requiredAuthorizationLevel),
handler);
}
public AvcTransformer(IHttpService http, IModuleService moduleService)
{
_http = http;
_moduleService = moduleService;
}
protected void RegisterUrlBased(IHttpService service, string uriTemplate, string httpMethod, AuthorizationLevel requiredAuthorizationLevel,
Action <HttpEntityManager, UriTemplateMatch> action)
{
Register(service, uriTemplate, httpMethod, action, Codec.NoCodecs, DefaultCodecs, requiredAuthorizationLevel);
}
public AccountsRepository(IHttpService httpService)
{
this.httpService = httpService;
}
public void Subscribe(IHttpService http)
{
_http = http;
Register("/", HttpMethod.Get);
Register("/ping", HttpMethod.Get);
Register("/halt", HttpMethod.Get);
Register("/shutdown", HttpMethod.Get);
Register("/streams/{stream}", HttpMethod.Post);
Register("/streams/{stream}", HttpMethod.Delete);
Register("/streams/{stream}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/{event}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/{event}/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/{event}/backward/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/{event}/forward/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/{event}/data", HttpMethod.Get);
Register("/streams/{stream}/{event}/metadata", HttpMethod.Get);
Register("/streams/{stream}/metadata", HttpMethod.Post);
Register("/streams/{stream}/metadata?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/metadata/{event}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/metadata/{event}/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/metadata/{event}/backward/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/metadata/{event}/forward/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/{stream}/metadata/data", HttpMethod.Get);
Register("/streams/{stream}/metadata/metadata", HttpMethod.Get);
Register("/streams/{stream}/metadata/{event}/data", HttpMethod.Get);
Register("/streams/{stream}/metadata/{event}/metadata", HttpMethod.Get);
Register("/streams/$all?embed={embed}", HttpMethod.Get);
Register("/streams/$all/{position}/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/$all/{position}/backward/{count}?embed={embed}", HttpMethod.Get);
Register("/streams/$all/{position}/forward/{count}?embed={embed}", HttpMethod.Get);
Register("/projections", HttpMethod.Get);
Register("/projections/any", HttpMethod.Get);
Register("/projections/all-non-transient", HttpMethod.Get);
Register("/projections/transient", HttpMethod.Get);
Register("/projections/onetime", HttpMethod.Get);
Register("/projections/continuous", HttpMethod.Get);
Register("/projections/transient?name={name}&type={type}&enabled={enabled}", HttpMethod.Post);
Register(
"/projections/onetime?name={name}&type={type}&enabled={enabled}&checkpoints={checkpoints}&emit={emit}",
HttpMethod.Post);
Register("/projections/continuous?name={name}&type={type}&enabled={enabled}&emit={emit}", HttpMethod.Post);
Register("/projection/{name}/query?config={config}", HttpMethod.Get);
Register("/projection/{name}/query?type={type}&emit={emit}", HttpMethod.Put);
Register("/projection/{name}", HttpMethod.Get);
Register(
"/projection/{name}?deleteStateStream={deleteStateStream}&deleteCheckpointStream={deleteCheckpointStream}",
HttpMethod.Delete);
Register("/projection/{name}/statistics", HttpMethod.Get);
Register("/projection/{name}/debug", HttpMethod.Get);
Register("/projection/{name}/state?partition={partition}", HttpMethod.Get);
Register("/projection/{name}/result?partition={partition}", HttpMethod.Get);
Register("/projection/{name}/command/disable", HttpMethod.Post);
Register("/projection/{name}/command/enable", HttpMethod.Post);
Register("/projection/{name}/command/reset", HttpMethod.Post);
Register("/stats", HttpMethod.Get);
Register("/stats/{*statPath}", HttpMethod.Get);
Register("/users/", HttpMethod.Get);
Register("/users/{login}", HttpMethod.Get);
Register("/users/", HttpMethod.Post);
Register("/users/{login}", HttpMethod.Put);
Register("/users/{login}", HttpMethod.Delete);
Register("/users/{login}/command/enable", HttpMethod.Post);
Register("/users/{login}/command/disable", HttpMethod.Post);
Register("/users/{login}/command/reset-password", HttpMethod.Post);
Register("/users/{login}/command/change-password", HttpMethod.Post);
}
public MoviesRepository(IHttpService httpService)
{
this.httpService = httpService;
}
public ReportService(IHttpService httpService_)
{
httpService = httpService_;
}
public HistoricoRepository(IHttpService httpService)
{
this.httpService = httpService;
}
protected EditFormEntityViewModelBase(ScreenSettings <EditFormSettingsDescriptor> screenSettings, UiNotificationService uiNotificationService, IHttpService httpService, IMapper mapper)
{
this.UiNotificationService = uiNotificationService;
FormSettings = screenSettings.Settings;
Buttons = new ObservableCollection <CommandButtonDescriptor>(screenSettings.CommandButtons);
fieldsCollectionHelper = new FieldsCollectionHelper(this.FormSettings, Properties, this.UiNotificationService, httpService, mapper);
fieldsCollectionHelper.CreateFieldsCollection();
propertyChangedSubscription = this.UiNotificationService.ValueChanged.Subscribe(FieldChanged);
}
/// <summary>
/// Initializes a new instance of the <see cref="PersonService"/> class.
/// </summary>
///
/// <param name="httpService">The http service.</param>
public PersonService(IHttpService httpService)
{
this.HttpService = httpService;
}
public AuditRepository(IHttpService httpService)
{
_httpService = httpService;
}
public StoreUserRepository(IHttpService httpService)
{
_httpService = httpService;
}
public DataModelCreate(IHttpService httpService)
{
this.httpService = httpService;
}
public void Subscribe(IHttpService service)
{
Ensure.NotNull(service, "service");
SubscribeCore(service);
}
public LciServiceDal(IHttpService httpService, Endpoints endpoints)
{
this.httpService = httpService;
this.endpoints = endpoints;
}
protected void Register(IHttpService service, string uriTemplate, string httpMethod,
Action<HttpEntityManager, UriTemplateMatch> handler, ICodec[] requestCodecs, ICodec[] responseCodecs)
{
service.RegisterControllerAction(new ControllerAction(uriTemplate, httpMethod, requestCodecs, responseCodecs), handler);
}
public RebuildController(IAdaptationServiceClient <AdaptationOutcomeProcessor> adaptationServiceClient, IStoreConfiguration storeConfiguration,
IProcessingConfiguration processingConfiguration, ILogger <RebuildController> logger, IFileUtility fileUtility,
IZipUtility zipUtility, ICloudSdkConfiguration cloudSdkConfiguration, IHttpService httpService) : base(logger, adaptationServiceClient, fileUtility, cloudSdkConfiguration,
processingConfiguration, storeConfiguration, zipUtility, httpService)
{
}
protected void RegisterTextBody(
IHttpService service, string uriTemplate, string httpMethod,
Action<HttpEntityManager, UriTemplateMatch, string> action, ICodec[] requestCodecs = null,
ICodec[] responseCodecs = null)
{
Register(
service, uriTemplate, httpMethod,
(http, match) => http.ReadTextRequestAsync((manager, s) => action(manager, match, s), LogError),
requestCodecs ?? _defaultCodecs, responseCodecs ?? _defaultCodecs);
}
public PersonRepository(IHttpService httpService)
{
this.httpService = httpService;
}
