/// <summary> /// Updates (or adds) the HATEOAS configuration /// </summary> /// <param name="configuration">HTTP configuration</param> /// <param name="hateoasConfiguration">HATEOAS configuration</param> public static void UpdateConfiguration(this IHttpConfiguration configuration, IHateoasConfiguration hateoasConfiguration) { configuration.Properties.AddOrUpdate( typeof(IHateoasConfiguration), hateoasConfiguration, (oldValue, newValue) => hateoasConfiguration); }
public ConfigurationProvider(IHttpConfiguration httpConfiguration, ILinkFactory linkFactory, IConfigurationProviderGetLinksForFuncProvider linksForFuncProvider, ICache <Type, Func <ConfigurationProvider, object, IEnumerable <IHateoasLink> > > getLinksForMethodCache) { _httpConfiguration = httpConfiguration; _linkFactory = linkFactory; _linksForFuncProvider = linksForFuncProvider; _getLinksForMethodCache = getLinksForMethodCache; }
public ReliableRestClientRestSharPolly(IHttpConfiguration httpConfiguration) : base(httpConfiguration.BaseUrl) { _retryPolicy = Policy .HandleResult <IRestResponse>(r => _httpStatusCodesWorthRetrying.Contains(r.StatusCode)) .WaitAndRetryAsync(_maxRetryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)) ); }
internal HateoasContainer(IHttpConfiguration httpConfiguration, HateoasConfiguration configuration) { Configuration = configuration; //Registrations = new List<IHateoasRegistration>(); _httpConfiguration = httpConfiguration; Update(); }
public HttpDataService( IHttpConfiguration configuration, IDataParser dataParser) { _dataParser = dataParser; _http = new HttpClient { BaseAddress = configuration.BaseUri }; }
/// <summary> /// Uploads a file to the SystemLink server using an in-memory stream. /// This allows the file to be created on the server without writing it /// to disk first. /// </summary> /// <param name="configuration">The HTTP configuration to connect to the SystemLink server.</param> /// <param name="fileName">The name for the uploaded file.</param> /// <param name="fileContents">An array of bytes to send for the contents of the file.</param> /// <returns>The ID of the file that was uploaded.</returns> public static string UploadFileData(IHttpConfiguration configuration, string fileName, byte[] fileContents) { // Upload a file using the SystemLink File client var fileUploader = new FileUploader(configuration); // Use in-memory data for the file upload. using (var memoryStream = new MemoryStream(fileContents)) { // Upload the file to the SystemLink server and get the ID for the uploaded file. var fileId = fileUploader.UploadFile(memoryStream, fileName); return(fileId); } }
/// <summary> /// Updates (or adds) an HATEOAS registration /// </summary> /// <param name="configuration">HTTP configuration</param> /// <param name="registration">HATEOAS registration</param> public static void UpdateRegistration(this IHttpConfiguration configuration, IHateoasRegistration registration) { var definition = configuration.GetRegistrationFor(registration.Model, registration.Relation, registration.IsCollection); if (definition == null) { configuration.AddRegistration(registration); } else { definition.Expression = registration.Expression; } }
/// <summary> /// Returns the HATEOASregistration for a specific model and relation. Returns null when the combination of model and relation could not be found. /// </summary> /// <param name="configuration">HTTP configuration</param> /// <param name="model">The model to get an HATEOAS registration for</param> /// <param name="relation">Relation to the model</param> /// <param name="isCollection">Indicates wether the source registration is s collection</param> /// <returns>HATEOAS registration for the model and relation specified</returns> public static IHateoasRegistration GetRegistrationFor(this IHttpConfiguration configuration, Type model, string relation, bool isCollection) { var definitions = configuration.GetRegistrationsFor(model); var definition = definitions.SingleOrDefault(def => def.Model == model && def.Relation == relation && def.IsCollection == isCollection); //if (definition == null) //{ // // TODO Maybe implement AddOrUpdate behavior? // throw new HateoasException($"No registration found for model {model} and relation {relation}"); //} return(definition); }
public static void Startup <TRegistrationClass>( IHttpConfiguration configuration, IAuthorizationProvider authorizationProvider = null, IDependencyResolver dependencyResolver = null, IList <IMessageSerializer> messageSerializers = null) where TRegistrationClass : IHateoasRegistrationProfile, new() { Startup( new TRegistrationClass(), configuration, authorizationProvider, dependencyResolver, messageSerializers); }
/// <summary> /// Returns the HATEOAS registrations for a specific model. Returns a (registered) empty list when the model could not be found. /// </summary> /// <param name="configuration">HTTP configuration</param> /// <param name="model">The model to get HATEOAS registrations for</param> /// <param name="isCollection"></param> /// <returns>HATEOAS registrations for the model specified</returns> public static List <IHateoasRegistration> GetRegistrationsFor(this IHttpConfiguration configuration, Type model) { var linkedResourceDefinitions = configuration.GetRegistrations(); List <IHateoasRegistration> definitions; if (linkedResourceDefinitions.TryGetValue(model, out definitions)) { return(definitions); } definitions = new List <IHateoasRegistration>(); linkedResourceDefinitions.Add(model, definitions); return(definitions); }
public static void Startup <TRegistrationClass>( TRegistrationClass registrationClass, IHttpConfiguration configuration, IAuthorizationProvider authorizationProvider = null, IDependencyResolver dependencyResolver = null, IList <IMessageSerializer> messageSerializers = null) where TRegistrationClass : IHateoasRegistrationProfile { var linkBuilderFactory = new LinkBuilderFactory(); // todo: this is not very clean; user dependencyresolver etc if (authorizationProvider == null) { var httpContextWrapper = new HttpContextWrapper(HttpContext.Current); authorizationProvider = new WebApiAuthorizationProvider(httpContextWrapper); } var idFromExpressionProcessor = new IdFromExpressionProcessor(dependencyResolver); var argumentsDefinitionsProcessor = new ArgumentDefinitionsProcessor(); var templateArgumentsProcessor = new TemplateArgumentsProcessor(); var linkFactory = new LinkFactory( linkBuilderFactory: linkBuilderFactory, authorizationProvider: authorizationProvider, idFromExpressionProcessor: idFromExpressionProcessor, argumentsDefinitionsProcessor: argumentsDefinitionsProcessor, templateArgumentsProcessor: templateArgumentsProcessor ); var inMemoryGenericLinksForMethodsCache = new InMemoryCache <int, MethodInfo>(); var linksForFuncProvider = new ConfigurationProviderGetLinksForFuncProvider(inMemoryGenericLinksForMethodsCache); var getLinksForMethodCache = new InMemoryCache <Type, Func <ConfigurationProvider, object, IEnumerable <IHateoasLink> > >(); var configurationProvider = new ConfigurationProvider(configuration, linkFactory, linksForFuncProvider, getLinksForMethodCache); var responseProvider = new ResponseProvider(configurationProvider); var handler = new HateoasHttpHandler(responseProvider, messageSerializers ?? new List <IMessageSerializer>()); configuration.MessageHandlers.Add(handler); var container = HateoasContainerFactory.Create(configuration); registrationClass.Register(container); }
private static void PublishMessages(IHttpConfiguration configuration) { /* * Open a separate session for publishing messages. This is not * required, but simulates how two separate applications can * communicate with each other using messages. */ Console.WriteLine("Publishing messages..."); using (var writeSession = MessageSession.Open(configuration)) { /* * Messages can contain any string. It's up to the application * to determine the data format to use for each message topic. * In this example, the example.data topic contains a JSON * representation of the MessageData class. */ var data = JsonConvert.SerializeObject(new MessageData { Message = "Hello World! PI=", Value = Math.PI }); writeSession.Publish("example.data", data); data = JsonConvert.SerializeObject(new MessageData { Message = "Another message, E=", Value = Math.E }); writeSession.Publish("example.data", data); /* * The server will ignore messages published to a topic with no * subscribers, but it's not an error. */ writeSession.Publish("example.unknown", "no subscribers"); /* * Publish messages to the example.exit topic to signal the * reader to stop. Both are queued, but only one is read. */ writeSession.Publish("example.exit", "first exit"); writeSession.Publish("example.exit", "second exit"); } }
public WebApiImageService(IHttpConfiguration httpConfiguration) : base(httpConfiguration) { }
public static HateoasContainer Create(IHttpConfiguration configuration) { return(new HateoasContainer(configuration, new HateoasConfiguration())); }
public WebApiAccountService(IHttpConfiguration httpConfiguration) : base(httpConfiguration) { }
protected HttpServiceBase(IHttpConfiguration httpConfiguration) => httpClient = new HttpClient
/// <summary> /// Returns a dictionary holding all HATEOAS registrations. /// </summary> /// <param name="configuration">source paramater</param> /// <returns>Dictionary holding all HATEOAS registrations</returns> public static Dictionary <Type, List <IHateoasRegistration> > GetRegistrations(this IHttpConfiguration configuration) { return((Dictionary <Type, List <IHateoasRegistration> >)configuration.Properties.GetOrAdd( typeof(Dictionary <Type, List <IHateoasRegistration> >), k => new Dictionary <Type, List <IHateoasRegistration> >() )); }
/// <summary> /// Adds an HATEOAS registration /// </summary> /// <param name="configuration">HTTP configuration</param> /// <param name="registration">HATEOAS registration</param> public static void AddRegistration(this IHttpConfiguration configuration, IHateoasRegistration registration) { var definitions = configuration.GetRegistrationsFor(registration.Model); definitions.Add(registration); }
/// <summary> /// Returns the HATEOAS registrations for a specific model. Returns a (registered) empty list when the model could not be found. /// </summary> /// <param name="configuration">HTTP configuration</param> /// <param name="model">The model to get HATEOAS registrations for</param> /// <param name="isCollection"></param> /// <returns>HATEOAS registrations for the model specified</returns> public static List <IHateoasRegistration <TModel> > GetRegistrationsFor <TModel>(this IHttpConfiguration configuration) { return(configuration .GetRegistrationsFor(typeof(TModel)) .Cast <IHateoasRegistration <TModel> >() .ToList()); }
/// <summary> /// Gets (or adds) the HATEOAS configuration /// </summary> /// <param name="configuration"></param> /// <returns></returns> public static IHateoasConfiguration GetConfiguration(this IHttpConfiguration configuration) { return((IHateoasConfiguration)configuration.Properties.GetOrAdd(typeof(IHateoasConfiguration), p => new HateoasConfiguration())); }